reactos/lib/kernel32/misc/stubs.c

   1 /* $Id: stubs.c,v 1.10 1999/11/17 21:28:08 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 DWORD
 819 STDCALL
 820 ExpungeConsoleCommandHistoryW (
 821         DWORD   Unknown0
 822         )
 823 {
 824         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 825         return 0;
 826 }
 827
 828
 829 DWORD
 830 STDCALL
 831 ExpungeConsoleCommandHistoryA (
 832         DWORD   Unknown0
 833         )
 834 {
 835         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 836         return 0;
 837 }
 838
 839
 840 BOOL
 841 STDCALL
 842 ExtendVirtualBuffer (
 843         DWORD   Unknown0,
 844         DWORD   Unknown1
 845         )
 846 {
 847         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 848         return FALSE;
 849 }
 850
 851
 852 VOID
 853 STDCALL
 854 FatalExit (
 855           int ExitCode
 856           )
 857 {
 858         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 859 }
 860
 861
 862 ATOM
 863 STDCALL
 864 FindAtomW (
 865         LPCWSTR lpString
 866         )
 867 {
 868         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 869         return 0;
 870 }
 871
 872
 873 ATOM
 874 STDCALL
 875 FindAtomA (
 876         LPCSTR lpString
 877         )
 878 {
 879         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 880         return 0;
 881 }
 882
 883
 884 WINBOOL
 885 STDCALL
 886 FindCloseChangeNotification (
 887         HANDLE  hChangeHandle
 888         )
 889 {
 890         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 891         return FALSE;
 892 }
 893
 894
 895 HANDLE
 896 STDCALL
 897 FindFirstChangeNotificationW (
 898         LPCWSTR lpPathName,
 899         WINBOOL bWatchSubtree,
 900         DWORD   dwNotifyFilter
 901         )
 902 {
 903         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 904         return INVALID_HANDLE_VALUE;
 905 }
 906
 907
 908 HANDLE
 909 STDCALL
 910 FindFirstChangeNotificationA (
 911         LPCSTR  lpPathName,
 912         WINBOOL bWatchSubtree,
 913         DWORD   dwNotifyFilter
 914         )
 915 {
 916         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 917         return INVALID_HANDLE_VALUE;
 918 }
 919
 920
 921 WINBOOL
 922 STDCALL
 923 FindNextChangeNotification (
 924         HANDLE  hChangeHandle
 925         )
 926 {
 927         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 928         return FALSE;
 929 }
 930
 931
 932
 933 int
 934 STDCALL
 935 FoldStringW (
 936         DWORD   dwMapFlags,
 937         LPCWSTR lpSrcStr,
 938         int     cchSrc,
 939         LPWSTR  lpDestStr,
 940         int     cchDest
 941         )
 942 {
 943         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 944         return 0;
 945 }
 946
 947
 948 int
 949 STDCALL
 950 FoldStringA (
 951         DWORD   dwMapFlags,
 952         LPCSTR  lpSrcStr,
 953         int     cchSrc,
 954         LPSTR   lpDestStr,
 955         int     cchDest
 956         )
 957 {
 958         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 959         return 0;
 960 }
 961
 962
 963 DWORD
 964 STDCALL
 965 FormatMessageW (
 966         DWORD   dwFlags,
 967         LPCVOID lpSource,
 968         DWORD   dwMessageId,
 969         DWORD   dwLanguageId,
 970         LPWSTR  lpBuffer,
 971         DWORD   nSize,
 972         va_list * Arguments
 973         )
 974 {
 975         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 976         return 0;
 977 }
 978
 979
 980 DWORD
 981 STDCALL
 982 FormatMessageA (
 983         DWORD   dwFlags,
 984         LPCVOID lpSource,
 985         DWORD   dwMessageId,
 986         DWORD   dwLanguageId,
 987         LPSTR   lpBuffer,
 988         DWORD   nSize,
 989         va_list * Arguments
 990         )
 991 {
 992         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 993         return 0;
 994 }
 995
 996
 997
 998
 999
1000
1001
1002 BOOL
1003 STDCALL
1004 FreeVirtualBuffer (
1005         HANDLE  hVirtualBuffer
1006         )
1007 {
1008         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1009         return FALSE;
1010 }
1011
1012
1013 UINT
1014 STDCALL
1015 GetACP (VOID)
1016 {
1017         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1018         return 0;
1019 }
1020
1021
1022
1023 UINT
1024 STDCALL
1025 GetAtomNameW (
1026         ATOM    nAtom,
1027         LPWSTR  lpBuffer,
1028         int     nSize
1029         )
1030 {
1031         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1032         return 0;
1033 }
1034
1035
1036 UINT
1037 STDCALL
1038 GetAtomNameA (
1039         ATOM    nAtom,
1040         LPSTR   lpBuffer,
1041         int     nSize
1042         )
1043 {
1044         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1045         return 0;
1046 }
1047
1048
1049 WINBOOL
1050 STDCALL
1051 GetBinaryTypeW (
1052         LPCWSTR lpApplicationName,
1053         LPDWORD lpBinaryType
1054         )
1055 {
1056         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1057         return FALSE;
1058 }
1059
1060
1061 WINBOOL
1062 STDCALL
1063 GetBinaryTypeA (
1064         LPCSTR  lpApplicationName,
1065         LPDWORD lpBinaryType
1066         )
1067 {
1068         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1069         return FALSE;
1070 }
1071
1072
1073 WINBOOL
1074 STDCALL
1075 GetCPInfo (
1076         UINT            a0,
1077         LPCPINFO        a1
1078         )
1079 {
1080         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1081         return 0;
1082 }
1083
1084
1085 WINBOOL
1086 STDCALL
1087 GetCommConfig (
1088         HANDLE          hCommDev,
1089         LPCOMMCONFIG    lpCC,
1090         LPDWORD         lpdwSize
1091         )
1092 {
1093         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1094         return FALSE;
1095 }
1096
1097
1098 WINBOOL
1099 STDCALL
1100 GetCommMask (
1101         HANDLE  hFile,
1102         LPDWORD lpEvtMask
1103         )
1104 {
1105         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1106         return FALSE;
1107 }
1108
1109
1110
1111 WINBOOL
1112 STDCALL
1113 GetCommModemStatus (
1114         HANDLE  hFile,
1115         LPDWORD lpModemStat
1116         )
1117 {
1118         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1119         return FALSE;
1120 }
1121
1122
1123 WINBOOL
1124 STDCALL
1125 GetCommProperties (
1126         HANDLE          hFile,
1127         LPCOMMPROP      lpCommProp
1128         )
1129 {
1130         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1131         return FALSE;
1132 }
1133
1134
1135 WINBOOL
1136 STDCALL
1137 GetCommState (
1138         HANDLE hFile,
1139         LPDCB lpDCB
1140         )
1141 {
1142         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1143         return FALSE;
1144 }
1145
1146
1147 WINBOOL
1148 STDCALL
1149 GetCommTimeouts (
1150         HANDLE          hFile,
1151         LPCOMMTIMEOUTS  lpCommTimeouts
1152         )
1153 {
1154         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1155         return FALSE;
1156 }
1157
1158
1159 WINBOOL
1160 STDCALL
1161 GetComputerNameW (
1162         LPWSTR lpBuffer,
1163         LPDWORD nSize
1164         )
1165 {
1166         WCHAR   Name [MAX_COMPUTERNAME_LENGTH + 1];
1167         DWORD   Size = 0;
1168
1169         /*
1170          * FIXME: get the computer's name from
1171          * the registry.
1172          */
1173         lstrcpyW( Name, L"ROSHost" ); /* <-- FIXME -- */
1174         Size = lstrlenW(Name) + 1;
1175         if (Size > *nSize)
1176         {
1177                 *nSize = Size;
1178                 SetLastError(ERROR_BUFFER_OVERFLOW);
1179                 return FALSE;
1180         }
1181         lstrcpyW( lpBuffer, Name );
1182         return TRUE;
1183 }
1184
1185
1186 WINBOOL
1187 STDCALL
1188 GetComputerNameA (
1189         LPSTR   lpBuffer,
1190         LPDWORD nSize
1191         )
1192 {
1193         WCHAR   Name [MAX_COMPUTERNAME_LENGTH + 1];
1194         int i;
1195
1196         if (FALSE == GetComputerNameW(
1197                         Name,
1198                         nSize
1199                         ))
1200         {
1201                 return FALSE;
1202         }
1203 /* FIXME --> */
1204 /* Use UNICODE to ANSI */
1205         for ( i=0; Name[i]; ++i )
1206         {
1207                 lpBuffer[i] = (CHAR) Name[i];
1208         }
1209         lpBuffer[i] = '\0';
1210 /* FIXME <-- */
1211         return TRUE;
1212 }
1213
1214
1215 DWORD
1216 STDCALL
1217 GetConsoleAliasW (
1218         DWORD   Unknown0,
1219         DWORD   Unknown1,
1220         DWORD   Unknown2,
1221         DWORD   Unknown3
1222         )
1223 {
1224         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1225         return 0;
1226 }
1227
1228
1229 DWORD
1230 STDCALL
1231 GetConsoleAliasA (
1232         DWORD   Unknown0,
1233         DWORD   Unknown1,
1234         DWORD   Unknown2,
1235         DWORD   Unknown3
1236         )
1237 {
1238         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1239         return 0;
1240 }
1241
1242
1243
1244 DWORD
1245 STDCALL
1246 GetConsoleAliasExesW (
1247         DWORD   Unknown0,
1248         DWORD   Unknown1
1249         )
1250 {
1251         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1252         return 0;
1253 }
1254
1255
1256
1257 DWORD
1258 STDCALL
1259 GetConsoleAliasExesA (
1260         DWORD   Unknown0,
1261         DWORD   Unknown1
1262         )
1263 {
1264         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1265         return 0;
1266 }
1267
1268
1269
1270 DWORD
1271 STDCALL
1272 GetConsoleAliasExesLengthA (VOID)
1273 {
1274         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1275         return 0;
1276 }
1277
1278
1279
1280 DWORD
1281 STDCALL
1282 GetConsoleAliasExesLengthW (VOID)
1283 {
1284         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1285         return 0;
1286 }
1287
1288
1289
1290 DWORD
1291 STDCALL
1292 GetConsoleAliasesW (
1293         DWORD   Unknown0,
1294         DWORD   Unknown1,
1295         DWORD   Unknown2
1296         )
1297 {
1298         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1299         return 0;
1300 }
1301
1302
1303
1304 DWORD
1305 STDCALL
1306 GetConsoleAliasesA (
1307         DWORD   Unknown0,
1308         DWORD   Unknown1,
1309         DWORD   Unknown2
1310         )
1311 {
1312         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1313         return 0;
1314 }
1315
1316
1317
1318 DWORD
1319 STDCALL
1320 GetConsoleAliasesLengthW (
1321         DWORD Unknown0
1322         )
1323 {
1324         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1325         return 0;
1326 }
1327
1328
1329
1330 DWORD
1331 STDCALL
1332 GetConsoleAliasesLengthA (
1333         DWORD Unknown0
1334         )
1335 {
1336         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1337         return 0;
1338 }
1339
1340
1341 DWORD
1342 STDCALL
1343 GetConsoleCommandHistoryW (
1344         DWORD   Unknown0,
1345         DWORD   Unknown1,
1346         DWORD   Unknown2
1347         )
1348 {
1349         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1350         return 0;
1351 }
1352
1353
1354 DWORD
1355 STDCALL
1356 GetConsoleCommandHistoryA (
1357         DWORD   Unknown0,
1358         DWORD   Unknown1,
1359         DWORD   Unknown2
1360         )
1361 {
1362         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1363         return 0;
1364 }
1365
1366
1367 DWORD
1368 STDCALL
1369 GetConsoleCommandHistoryLengthW (
1370         DWORD   Unknown0
1371         )
1372 {
1373         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1374         return 0;
1375 }
1376
1377
1378 DWORD
1379 STDCALL
1380 GetConsoleCommandHistoryLengthA (
1381         DWORD   Unknown0
1382         )
1383 {
1384         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1385         return 0;
1386 }
1387
1388
1389 DWORD
1390 STDCALL
1391 GetConsoleDisplayMode (
1392         DWORD   Unknown0
1393         )
1394 {
1395         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1396         return 0;
1397 }
1398
1399
1400 DWORD
1401 STDCALL
1402 GetConsoleFontInfo (
1403         DWORD   Unknown0,
1404         DWORD   Unknown1,
1405         DWORD   Unknown2,
1406         DWORD   Unknown3
1407         )
1408 {
1409         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1410         return 0;
1411 }
1412
1413
1414 DWORD
1415 STDCALL
1416 GetConsoleFontSize (
1417         DWORD   Unknown0,
1418         DWORD   Unknown1
1419         )
1420 {
1421         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1422         return 0;
1423 }
1424
1425
1426 DWORD
1427 STDCALL
1428 GetConsoleHardwareState (
1429         DWORD   Unknown0,
1430         DWORD   Unknown1,
1431         DWORD   Unknown2
1432         )
1433 {
1434         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1435         return 0;
1436 }
1437
1438
1439 DWORD
1440 STDCALL
1441 GetConsoleInputWaitHandle (VOID)
1442 {
1443         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1444         return FALSE;
1445 }
1446
1447
1448 int
1449 STDCALL
1450 GetCurrencyFormatW (
1451         LCID                    Locale,
1452         DWORD                   dwFlags,
1453         LPCWSTR                 lpValue,
1454         CONST CURRENCYFMT       * lpFormat,
1455         LPWSTR                  lpCurrencyStr,
1456         int                     cchCurrency
1457         )
1458 {
1459         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1460         return 0;
1461 }
1462
1463
1464 int
1465 STDCALL
1466 GetCurrencyFormatA (
1467         LCID                    Locale,
1468         DWORD                   dwFlags,
1469         LPCSTR                  lpValue,
1470         CONST CURRENCYFMT       * lpFormat,
1471         LPSTR                   lpCurrencyStr,
1472         int                     cchCurrency
1473         )
1474 {
1475         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1476         return 0;
1477 }
1478
1479
1480 DWORD
1481 STDCALL
1482 GetCurrentConsoleFont (
1483         DWORD   Unknown0,
1484         DWORD   Unknown1,
1485         DWORD   Unknown2
1486         )
1487 {
1488         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1489         return 0;
1490 }
1491
1492
1493 int
1494 STDCALL
1495 GetDateFormatW (
1496         LCID                    Locale,
1497         DWORD                   dwFlags,
1498         CONST SYSTEMTIME        * lpDate,
1499         LPCWSTR                 lpFormat,
1500         LPWSTR                  lpDateStr,
1501         int                     cchDate
1502         )
1503 {
1504         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1505         return 0;
1506 }
1507
1508
1509 int
1510 STDCALL
1511 GetDateFormatA (
1512         LCID                    Locale,
1513         DWORD                   dwFlags,
1514         CONST SYSTEMTIME        * lpDate,
1515         LPCSTR                  lpFormat,
1516         LPSTR                   lpDateStr,
1517         int                     cchDate
1518         )
1519 {
1520         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1521         return 0;
1522 }
1523
1524
1525 WINBOOL
1526 STDCALL
1527 GetDefaultCommConfigW (
1528         LPCWSTR         lpszName,
1529         LPCOMMCONFIG    lpCC,
1530         LPDWORD         lpdwSize
1531         )
1532 {
1533         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1534         return FALSE;
1535 }
1536
1537
1538 WINBOOL
1539 STDCALL
1540 GetDefaultCommConfigA (
1541         LPCSTR          lpszName,
1542         LPCOMMCONFIG    lpCC,
1543         LPDWORD         lpdwSize
1544         )
1545 {
1546         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1547         return FALSE;
1548 }
1549
1550
1551 int
1552 STDCALL
1553 GetLocaleInfoW (
1554         LCID    Locale,
1555         LCTYPE  LCType,
1556         LPWSTR  lpLCData,
1557         int     cchData
1558         )
1559 {
1560         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1561         return 0;
1562 }
1563
1564
1565 int
1566 STDCALL
1567 GetLocaleInfoA (
1568         LCID    Locale,
1569         LCTYPE  LCType,
1570         LPSTR   lpLCData,
1571         int     cchData
1572         )
1573 {
1574         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1575         return 0;
1576 }
1577
1578
1579 WINBOOL
1580 STDCALL
1581 GetMailslotInfo (
1582         HANDLE  hMailslot,
1583         LPDWORD lpMaxMessageSize,
1584         LPDWORD lpNextSize,
1585         LPDWORD lpMessageCount,
1586         LPDWORD lpReadTimeout
1587         )
1588 {
1589         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1590         return FALSE;
1591 }
1592
1593
1594 DWORD
1595 STDCALL
1596 GetModuleFileNameW (
1597         HINSTANCE       hModule,
1598         LPWSTR          lpFilename,
1599         DWORD           nSize
1600         )
1601 {
1602         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1603         return 0;
1604 }
1605
1606
1607 DWORD
1608 STDCALL
1609 GetModuleFileNameA (
1610         HINSTANCE       hModule,
1611         LPSTR           lpFilename,
1612         DWORD           nSize
1613         )
1614 {
1615         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1616         return 0;
1617 }
1618
1619
1620 HMODULE
1621 STDCALL
1622 GetModuleHandleW (
1623         LPCWSTR lpModuleName
1624         )
1625 {
1626         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1627         return INVALID_HANDLE_VALUE;
1628 }
1629
1630
1631
1632
1633
1634 WINBOOL
1635 STDCALL
1636 GetNamedPipeHandleStateW (
1637         HANDLE  hNamedPipe,
1638         LPDWORD lpState,
1639         LPDWORD lpCurInstances,
1640         LPDWORD lpMaxCollectionCount,
1641         LPDWORD lpCollectDataTimeout,
1642         LPWSTR  lpUserName,
1643         DWORD   nMaxUserNameSize
1644         )
1645 {
1646         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1647         return FALSE;
1648 }
1649
1650
1651 WINBOOL
1652 STDCALL
1653 GetNamedPipeHandleStateA (
1654         HANDLE  hNamedPipe,
1655         LPDWORD lpState,
1656         LPDWORD lpCurInstances,
1657         LPDWORD lpMaxCollectionCount,
1658         LPDWORD lpCollectDataTimeout,
1659         LPSTR   lpUserName,
1660         DWORD   nMaxUserNameSize
1661         )
1662 {
1663         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1664         return FALSE;
1665 }
1666
1667
1668 WINBOOL
1669 STDCALL
1670 GetNamedPipeInfo (
1671         HANDLE  hNamedPipe,
1672         LPDWORD lpFlags,
1673         LPDWORD lpOutBufferSize,
1674         LPDWORD lpInBufferSize,
1675         LPDWORD lpMaxInstances
1676         )
1677 {
1678         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1679         return FALSE;
1680 }
1681
1682
1683 DWORD
1684 STDCALL
1685 GetNextVDMCommand (
1686         DWORD   Unknown0
1687         )
1688 {
1689         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1690         return 0;
1691 }
1692
1693
1694 int
1695 STDCALL
1696 GetNumberFormatW (
1697         LCID            Locale,
1698         DWORD           dwFlags,
1699         LPCWSTR         lpValue,
1700         CONST NUMBERFMT * lpFormat,
1701         LPWSTR          lpNumberStr,
1702         int             cchNumber
1703         )
1704 {
1705         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1706         return 0;
1707 }
1708
1709
1710 int
1711 STDCALL
1712 GetNumberFormatA (
1713         LCID            Locale,
1714         DWORD           dwFlags,
1715         LPCSTR          lpValue,
1716         CONST NUMBERFMT * lpFormat,
1717         LPSTR           lpNumberStr,
1718         int             cchNumber
1719         )
1720 {
1721         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1722         return 0;
1723 }
1724
1725
1726 int
1727 STDCALL
1728 GetNumberOfConsoleFonts (VOID)
1729 {
1730         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1731         return 1; /* FIXME: call csrss.exe */
1732 }
1733
1734
1735 UINT
1736 STDCALL
1737 GetOEMCP (VOID)
1738 {
1739         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1740         return 437; /* FIXME: call csrss.exe */
1741 }
1742
1743
1744 DWORD
1745 STDCALL
1746 GetPriorityClass (
1747         HANDLE  hProcess
1748         )
1749 {
1750         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1751         return NORMAL_PRIORITY_CLASS; /* FIXME: call NTOSKRNL.Ps */
1752 }
1753
1754
1755
1756 UINT
1757 STDCALL
1758 GetPrivateProfileIntW (
1759         LPCWSTR lpAppName,
1760         LPCWSTR lpKeyName,
1761         INT     nDefault,
1762         LPCWSTR lpFileName
1763         )
1764 {
1765         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1766         return 0;
1767 }
1768
1769
1770 UINT
1771 STDCALL
1772 GetPrivateProfileIntA (
1773         LPCSTR  lpAppName,
1774         LPCSTR  lpKeyName,
1775         INT     nDefault,
1776         LPCSTR  lpFileName
1777         )
1778 {
1779         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1780         return 0;
1781 }
1782
1783
1784 DWORD
1785 STDCALL
1786 GetPrivateProfileSectionW (
1787         LPCWSTR lpAppName,
1788         LPWSTR  lpReturnedString,
1789         DWORD   nSize,
1790         LPCWSTR lpFileName
1791         )
1792 {
1793         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1794         return 0;
1795 }
1796
1797
1798 DWORD
1799 STDCALL
1800 GetPrivateProfileSectionA (
1801         LPCSTR  lpAppName,
1802         LPSTR   lpReturnedString,
1803         DWORD   nSize,
1804         LPCSTR  lpFileName
1805         )
1806 {
1807         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1808         return 0;
1809 }
1810
1811
1812 DWORD
1813 STDCALL
1814 GetPrivateProfileSectionNamesW (
1815         DWORD   Unknown0,
1816         DWORD   Unknown1,
1817         DWORD   Unknown2
1818         )
1819 {
1820         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1821         return 0;
1822 }
1823
1824
1825 DWORD
1826 STDCALL
1827 GetPrivateProfileSectionNamesA (
1828         DWORD   Unknown0,
1829         DWORD   Unknown1,
1830         DWORD   Unknown2
1831         )
1832 {
1833         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1834         return 0;
1835 }
1836
1837
1838 DWORD
1839 STDCALL
1840 GetPrivateProfileStringW (
1841         LPCWSTR lpAppName,
1842         LPCWSTR lpKeyName,
1843         LPCWSTR lpDefault,
1844         LPWSTR  lpReturnedString,
1845         DWORD   nSize,
1846         LPCWSTR lpFileName
1847         )
1848 {
1849         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1850         return 0;
1851 }
1852
1853
1854 DWORD
1855 STDCALL
1856 GetPrivateProfileStringA (
1857         LPCSTR  lpAppName,
1858         LPCSTR  lpKeyName,
1859         LPCSTR  lpDefault,
1860         LPSTR   lpReturnedString,
1861         DWORD   nSize,
1862         LPCSTR  lpFileName
1863         )
1864 {
1865         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1866         return 0;
1867 }
1868
1869
1870 DWORD
1871 STDCALL
1872 GetPrivateProfileStructW (
1873         DWORD   Unknown0,
1874         DWORD   Unknown1,
1875         DWORD   Unknown2,
1876         DWORD   Unknown3,
1877         DWORD   Unknown4
1878         )
1879 {
1880         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1881         return 0;
1882 }
1883
1884
1885 DWORD
1886 STDCALL
1887 GetPrivateProfileStructA (
1888         DWORD   Unknown0,
1889         DWORD   Unknown1,
1890         DWORD   Unknown2,
1891         DWORD   Unknown3,
1892         DWORD   Unknown4
1893         )
1894 {
1895         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1896         return 0;
1897 }
1898
1899
1900 WINBOOL
1901 STDCALL
1902 GetProcessAffinityMask (
1903         HANDLE  hProcess,
1904         LPDWORD lpProcessAffinityMask,
1905         LPDWORD lpSystemAffinityMask
1906         )
1907 {
1908         if (    (NULL == lpProcessAffinityMask)
1909                 || (NULL == lpSystemAffinityMask)
1910                 )
1911         {
1912                 SetLastError(ERROR_BAD_ARGUMENTS);
1913                 return FALSE;
1914         }
1915         /* FIXME: check hProcess is actually a process */
1916         /* FIXME: query the kernel process object */
1917         *lpProcessAffinityMask = 0x00000001;
1918         *lpSystemAffinityMask  = 0x00000001;
1919         return TRUE;
1920 }
1921
1922
1923 WINBOOL
1924 STDCALL
1925 GetProcessShutdownParameters (
1926         LPDWORD lpdwLevel,
1927         LPDWORD lpdwFlags
1928         )
1929 {
1930         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1931         return FALSE;
1932 }
1933
1934
1935 DWORD
1936 STDCALL
1937 GetProcessVersion (
1938         DWORD   Unknown0
1939         )
1940 {
1941         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1942         return 0;
1943 }
1944
1945
1946 WINBOOL
1947 STDCALL
1948 GetProcessWorkingSetSize (
1949         HANDLE  hProcess,
1950         LPDWORD lpMinimumWorkingSetSize,
1951         LPDWORD lpMaximumWorkingSetSize
1952         )
1953 {
1954         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1955         return FALSE;
1956 }
1957
1958
1959 UINT
1960 STDCALL
1961 GetProfileIntW (
1962         LPCWSTR lpAppName,
1963         LPCWSTR lpKeyName,
1964         INT     nDefault
1965         )
1966 {
1967         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1968         return 0;
1969 }
1970
1971
1972 UINT
1973 STDCALL
1974 GetProfileIntA (
1975         LPCSTR  lpAppName,
1976         LPCSTR  lpKeyName,
1977         INT     nDefault
1978         )
1979 {
1980         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1981         return 0;
1982 }
1983
1984
1985 DWORD
1986 STDCALL
1987 GetProfileSectionW (
1988         LPCWSTR lpAppName,
1989         LPWSTR  lpReturnedString,
1990         DWORD   nSize
1991         )
1992 {
1993         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1994         return 0;
1995 }
1996
1997
1998 DWORD
1999 STDCALL
2000 GetProfileSectionA (
2001         LPCSTR  lpAppName,
2002         LPSTR   lpReturnedString,
2003         DWORD   nSize
2004         )
2005 {
2006         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2007         return 0;
2008 }
2009
2010
2011 DWORD
2012 STDCALL
2013 GetProfileStringW (
2014         LPCWSTR lpAppName,
2015         LPCWSTR lpKeyName,
2016         LPCWSTR lpDefault,
2017         LPWSTR  lpReturnedString,
2018         DWORD   nSize
2019         )
2020 {
2021         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2022         return 0;
2023 }
2024
2025
2026 DWORD
2027 STDCALL
2028 GetProfileStringA (
2029         LPCSTR  lpAppName,
2030         LPCSTR  lpKeyName,
2031         LPCSTR  lpDefault,
2032         LPSTR   lpReturnedString,
2033         DWORD   nSize
2034         )
2035 {
2036         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2037         return 0;
2038 }
2039
2040
2041 WINBOOL
2042 STDCALL
2043 GetStringTypeExW (
2044         LCID    Locale,
2045         DWORD   dwInfoType,
2046         LPCWSTR lpSrcStr,
2047         int     cchSrc,
2048         LPWORD  lpCharType
2049         )
2050 {
2051         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2052         return FALSE;
2053 }
2054
2055
2056 WINBOOL
2057 STDCALL
2058 GetStringTypeExA (
2059         LCID    Locale,
2060         DWORD   dwInfoType,
2061         LPCSTR  lpSrcStr,
2062         int     cchSrc,
2063         LPWORD  lpCharType
2064         )
2065 {
2066         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2067         return FALSE;
2068 }
2069
2070
2071 WINBOOL
2072 STDCALL
2073 GetStringTypeW (
2074         DWORD   dwInfoType,
2075         LPCWSTR lpSrcStr,
2076         int     cchSrc,
2077         LPWORD  lpCharType
2078         )
2079 {
2080         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2081         return FALSE;
2082 }
2083
2084
2085 WINBOOL
2086 STDCALL
2087 GetStringTypeA (
2088         LCID    Locale,
2089         DWORD   dwInfoType,
2090         LPCSTR  lpSrcStr,
2091         int     cchSrc,
2092         LPWORD  lpCharType
2093         )
2094 {
2095         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2096         return FALSE;
2097 }
2098
2099
2100 LCID
2101 STDCALL
2102 GetSystemDefaultLCID (VOID)
2103 {
2104         /* FIXME: ??? */
2105         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2106         return MAKELCID(
2107                 LANG_ENGLISH,
2108                 SORT_DEFAULT
2109                 );
2110 }
2111
2112
2113 LANGID
2114 STDCALL
2115 GetSystemDefaultLangID (VOID)
2116 {
2117          /* FIXME: ??? */
2118         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2119         return MAKELANGID(
2120                 LANG_ENGLISH,
2121                 SUBLANG_ENGLISH_US
2122                 );
2123 }
2124
2125
2126 VOID
2127 STDCALL
2128 GetSystemInfo (
2129         LPSYSTEM_INFO   lpSystemInfo
2130         )
2131 {
2132         /* FIXME: ??? */
2133         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2134
2135         lpSystemInfo->u.s.wProcessorArchitecture =
2136                 PROCESSOR_ARCHITECTURE_INTEL;
2137         lpSystemInfo->u.s.wReserved =
2138                 0;
2139         lpSystemInfo->dwPageSize =
2140                 4096; /* FIXME: x86 default; may be 4Mb  */
2141         lpSystemInfo->lpMinimumApplicationAddress =
2142                 (PVOID) 0x00010000; /* ? */
2143         lpSystemInfo->lpMaximumApplicationAddress =
2144                 (PVOID) 0x00010000; /* ? */
2145         lpSystemInfo->dwActiveProcessorMask =
2146                 0x00000001;
2147         lpSystemInfo->dwNumberOfProcessors =
2148                 1; /* ReactOS is UP for now! */
2149         lpSystemInfo->dwProcessorType =
2150                 PROCESSOR_INTEL_PENTIUM;
2151         lpSystemInfo->dwAllocationGranularity =
2152                 65536; /* hard coded on Intel? */
2153         lpSystemInfo->wProcessorLevel =
2154                 5; /* from cpuid on Intel? */
2155         lpSystemInfo->wProcessorRevision =
2156                 0x0000; /* from cpuid on Intel? */
2157 }
2158
2159
2160 DWORD
2161 STDCALL
2162 GetSystemPowerStatus (
2163         DWORD   Unknown0
2164         )
2165 {
2166         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2167         return 0;
2168 }
2169
2170
2171 DWORD
2172 STDCALL
2173 GetTapeParameters (
2174         HANDLE  hDevice,
2175         DWORD   dwOperation,
2176         LPDWORD lpdwSize,
2177         LPVOID  lpTapeInformation
2178         )
2179 {
2180         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2181         return 0;
2182 }
2183
2184
2185 DWORD
2186 STDCALL
2187 GetTapeStatus (
2188         HANDLE  hDevice
2189         )
2190 {
2191         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2192         return 0;
2193 }
2194
2195
2196 LCID
2197 STDCALL
2198 GetThreadLocale (VOID)
2199 {
2200         /* FIXME: ??? */
2201         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2202         return MAKELCID(
2203                 LANG_ENGLISH,
2204                 SORT_DEFAULT
2205                 );
2206 }
2207
2208
2209 WINBOOL
2210 STDCALL
2211 GetThreadSelectorEntry (
2212         HANDLE          hThread,
2213         DWORD           dwSelector,
2214         LPLDT_ENTRY     lpSelectorEntry
2215         )
2216 {
2217         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2218         return FALSE;
2219 }
2220
2221
2222 int
2223 STDCALL
2224 GetTimeFormatW (
2225         LCID                    Locale,
2226         DWORD                   dwFlags,
2227         CONST SYSTEMTIME        * lpTime,
2228         LPCWSTR                 lpFormat,
2229         LPWSTR                  lpTimeStr,
2230         int                     cchTime
2231         )
2232 {
2233         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2234         return 0;
2235 }
2236
2237
2238 int
2239 STDCALL
2240 GetTimeFormatA (
2241         LCID                    Locale,
2242         DWORD                   dwFlags,
2243         CONST SYSTEMTIME        * lpTime,
2244         LPCSTR                  lpFormat,
2245         LPSTR                   lpTimeStr,
2246         int                     cchTime
2247         )
2248 {
2249         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2250         return 0;
2251 }
2252
2253
2254 LCID
2255 STDCALL
2256 GetUserDefaultLCID (VOID)
2257 {
2258         /* FIXME: ??? */
2259         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2260         return MAKELCID(
2261                 LANG_ENGLISH,
2262                 SORT_DEFAULT
2263                 );
2264 }
2265
2266
2267 LANGID
2268 STDCALL
2269 GetUserDefaultLangID (VOID)
2270 {
2271          /* FIXME: ??? */
2272         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2273         return MAKELANGID(
2274                 LANG_ENGLISH,
2275                 SUBLANG_ENGLISH_US
2276                 );
2277 }
2278
2279
2280 DWORD
2281 STDCALL
2282 GetVDMCurrentDirectories (
2283         DWORD   Unknown0,
2284         DWORD   Unknown1
2285         )
2286 {
2287         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2288         return 0;
2289 }
2290
2291
2292 ATOM
2293 STDCALL
2294 GlobalAddAtomW (
2295         LPCWSTR lpString
2296         )
2297 {
2298         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2299         return 0;
2300 }
2301
2302
2303 ATOM
2304 STDCALL
2305 GlobalAddAtomA (
2306         LPCSTR  lpString
2307         )
2308 {
2309         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2310         return 0;
2311 }
2312
2313
2314 HGLOBAL
2315 STDCALL
2316 GlobalAlloc (
2317         UINT    uFlags,
2318         DWORD   dwBytes
2319         )
2320 {
2321         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2322         return 0;
2323 }
2324
2325
2326 UINT
2327 STDCALL
2328 GlobalCompact (
2329         DWORD   dwMinFree
2330         )
2331 {
2332         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2333         return 0;
2334 }
2335
2336
2337 ATOM
2338 STDCALL
2339 GlobalDeleteAtom (
2340         ATOM    nAtom
2341         )
2342 {
2343         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2344         return 0;
2345 }
2346
2347
2348 ATOM
2349 STDCALL
2350 GlobalFindAtomW (
2351         LPCWSTR lpString
2352         )
2353 {
2354         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2355         return 0;
2356 }
2357
2358
2359 ATOM
2360 STDCALL
2361 GlobalFindAtomA (
2362         LPCSTR  lpString
2363         )
2364 {
2365         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2366         return 0;
2367 }
2368
2369
2370 VOID
2371 STDCALL
2372 GlobalFix (
2373         HGLOBAL hMem
2374         )
2375 {
2376         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2377 }
2378
2379
2380 UINT
2381 STDCALL
2382 GlobalFlags (
2383         HGLOBAL hMem
2384         )
2385 {
2386         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2387         return 0;
2388 }
2389
2390
2391 HGLOBAL
2392 STDCALL
2393 GlobalFree (
2394         HGLOBAL hMem
2395         )
2396 {
2397         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2398         return hMem;
2399 }
2400
2401
2402 UINT
2403 STDCALL
2404 GlobalGetAtomNameA (
2405         ATOM    nAtom,
2406         LPSTR   lpBuffer,
2407         int     nSize
2408         )
2409 {
2410         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2411         return 0;
2412 }
2413
2414
2415 UINT
2416 STDCALL
2417 GlobalGetAtomNameW (
2418         ATOM    nAtom,
2419         LPWSTR  lpBuffer,
2420         int     nSize
2421         )
2422 {
2423         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2424         return 0;
2425 }
2426
2427
2428 HGLOBAL
2429 STDCALL
2430 GlobalHandle (
2431         LPCVOID pMem
2432         )
2433 {
2434         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2435         return 0;
2436 }
2437
2438
2439 LPVOID
2440 STDCALL
2441 GlobalLock (
2442         HGLOBAL hMem
2443         )
2444 {
2445         /* In Win32 GlobalAlloc returns LPVOID? */
2446         return hMem;
2447 }
2448
2449
2450 VOID
2451 STDCALL
2452 GlobalMemoryStatus (
2453         LPMEMORYSTATUS  lpBuffer
2454         )
2455 {
2456         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2457 }
2458
2459
2460 HGLOBAL
2461 STDCALL
2462 GlobalReAlloc (
2463         HGLOBAL hMem,
2464         DWORD   dwBytes,
2465         UINT    uFlags
2466         )
2467 {
2468         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2469         return 0;
2470 }
2471
2472
2473 DWORD
2474 STDCALL
2475 GlobalSize (
2476         HGLOBAL hMem
2477         )
2478 {
2479         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2480         return 0;
2481 }
2482
2483
2484 WINBOOL
2485 STDCALL
2486 GlobalUnWire (
2487         HGLOBAL hMem
2488         )
2489 {
2490         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2491         return FALSE;
2492 }
2493
2494
2495 VOID
2496 STDCALL
2497 GlobalUnfix (
2498         HGLOBAL hMem
2499         )
2500 {
2501         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2502 }
2503
2504
2505 WINBOOL
2506 STDCALL
2507 GlobalUnlock (
2508         HGLOBAL hMem
2509         )
2510 {
2511         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2512         return FALSE;
2513 }
2514
2515
2516 LPVOID
2517 STDCALL
2518 GlobalWire (
2519         HGLOBAL hMem
2520         )
2521 {
2522         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2523         return NULL; /* ? */
2524 }
2525
2526
2527 DWORD
2528 STDCALL
2529 HeapCreateTagsW (
2530         DWORD   Unknown0,
2531         DWORD   Unknown1,
2532         DWORD   Unknown2,
2533         DWORD   Unknown3
2534         )
2535 {
2536         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2537         return 0;
2538 }
2539
2540
2541 DWORD
2542 STDCALL
2543 HeapExtend (
2544         DWORD   Unknown0,
2545         DWORD   Unknown1,
2546         DWORD   Unknown2,
2547         DWORD   Unknown3
2548         )
2549 {
2550         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2551         return 0;
2552 }
2553
2554
2555 DWORD
2556 STDCALL
2557 HeapQueryTagW (
2558         DWORD   Unknown0,
2559         DWORD   Unknown1,
2560         DWORD   Unknown2,
2561         DWORD   Unknown3,
2562         DWORD   Unknown4
2563         )
2564 {
2565         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2566         return 0;
2567 }
2568
2569
2570 DWORD
2571 STDCALL
2572 HeapSummary (
2573         DWORD   Unknown0,
2574         DWORD   Unknown1,
2575         DWORD   Unknown2
2576         )
2577 {
2578         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2579         return 0;
2580 }
2581
2582
2583 DWORD
2584 STDCALL
2585 HeapUsage (
2586         DWORD   Unknown0,
2587         DWORD   Unknown1,
2588         DWORD   Unknown2,
2589         DWORD   Unknown3,
2590         DWORD   Unknown4
2591         )
2592 {
2593         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2594         return 0;
2595 }
2596
2597
2598 WINBOOL
2599 STDCALL
2600 HeapWalk (
2601         HANDLE                  hHeap,
2602         LPPROCESS_HEAP_ENTRY    lpEntry
2603         )
2604 {
2605         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2606         return FALSE;
2607 }
2608
2609
2610 WINBOOL
2611 STDCALL
2612 InitAtomTable (
2613         DWORD nSize
2614         )
2615 {
2616         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2617         return FALSE;
2618 }
2619
2620
2621 DWORD
2622 STDCALL
2623 InvalidateConsoleDIBits (
2624         DWORD   Unknown0,
2625         DWORD   Unknown1
2626         )
2627 {
2628         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2629         return 0;
2630 }
2631
2632
2633 WINBOOL
2634 STDCALL
2635 IsDBCSLeadByte (
2636         BYTE    TestChar
2637         )
2638 {
2639         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2640         return FALSE;
2641 }
2642
2643
2644 WINBOOL
2645 STDCALL
2646 IsDBCSLeadByteEx (
2647         UINT    CodePage,
2648         BYTE    TestChar
2649         )
2650 {
2651         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2652         return FALSE;
2653 }
2654
2655
2656 BOOL
2657 STDCALL
2658 IsDebuggerPresent (VOID)
2659 {
2660         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2661         return FALSE; /* FIXME: */
2662 }
2663
2664
2665 WINBOOL
2666 STDCALL
2667 IsValidCodePage (
2668         UINT    CodePage
2669         )
2670 {
2671         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2672         return FALSE;
2673 }
2674
2675
2676 WINBOOL
2677 STDCALL
2678 IsValidLocale (
2679         LCID    Locale,
2680         DWORD   dwFlags
2681         )
2682 {
2683         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2684         return FALSE;
2685 }
2686
2687
2688 int
2689 STDCALL
2690 LCMapStringA (
2691         LCID    Locale,
2692         DWORD   dwMapFlags,
2693         LPCSTR  lpSrcStr,
2694         int     cchSrc,
2695         LPSTR   lpDestStr,
2696         int     cchDest
2697         )
2698 {
2699         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2700         return 0;
2701 }
2702
2703
2704 int
2705 STDCALL
2706 LCMapStringW (
2707         LCID    Locale,
2708         DWORD   dwMapFlags,
2709         LPCWSTR lpSrcStr,
2710         int     cchSrc,
2711         LPWSTR  lpDestStr,
2712         int     cchDest
2713         )
2714 {
2715         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2716         return 0;
2717 }
2718
2719
2720 HINSTANCE
2721 STDCALL
2722 LoadLibraryExA (
2723         LPCSTR  lpLibFileName,
2724         HANDLE  hFile,
2725         DWORD   dwFlags
2726         )
2727 {
2728         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2729         return 0;
2730 }
2731
2732
2733 HINSTANCE
2734 STDCALL
2735 LoadLibraryExW (
2736         LPCWSTR lpLibFileName,
2737         HANDLE  hFile,
2738         DWORD   dwFlags
2739         )
2740 {
2741         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2742         return 0;
2743 }
2744
2745
2746 DWORD
2747 STDCALL
2748 LoadModule (
2749         LPCSTR  lpModuleName,
2750         LPVOID  lpParameterBlock
2751         )
2752 {
2753         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2754         return 0;
2755 }
2756
2757
2758
2759
2760
2761 HLOCAL
2762 STDCALL
2763 LocalAlloc (
2764         UINT    uFlags,
2765         UINT    uBytes
2766         )
2767 {
2768         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2769         return 0;
2770 }
2771
2772
2773 UINT
2774 STDCALL
2775 LocalCompact (
2776         UINT    uMinFree
2777         )
2778 {
2779         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2780         return 0;
2781 }
2782
2783
2784 UINT
2785 STDCALL
2786 LocalFlags (
2787         HLOCAL  hMem
2788         )
2789 {
2790         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2791         return 0;
2792 }
2793
2794
2795 HLOCAL
2796 STDCALL
2797 LocalFree (
2798         HLOCAL  hMem
2799         )
2800 {
2801         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2802         return hMem;
2803 }
2804
2805
2806 HLOCAL
2807 STDCALL
2808 LocalHandle (
2809         LPCVOID pMem
2810         )
2811 {
2812         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2813         return 0;
2814 }
2815
2816
2817 LPVOID
2818 STDCALL
2819 LocalLock (
2820         HLOCAL  hMem
2821         )
2822 {
2823         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2824         return NULL;
2825 }
2826
2827
2828 HLOCAL
2829 STDCALL
2830 LocalReAlloc (
2831         HLOCAL  hMem,
2832         UINT    uBytes,
2833         UINT    uFlags
2834         )
2835 {
2836         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2837         return 0;
2838 }
2839
2840
2841 UINT
2842 STDCALL
2843 LocalShrink (
2844         HLOCAL  hMem,
2845         UINT    cbNewSize
2846         )
2847 {
2848         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2849         return 0;
2850 }
2851
2852
2853 UINT
2854 STDCALL
2855 LocalSize (
2856         HLOCAL  hMem
2857         )
2858 {
2859         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2860         return 0;
2861 }
2862
2863
2864 WINBOOL
2865 STDCALL
2866 LocalUnlock (
2867         HLOCAL  hMem
2868         )
2869 {
2870         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2871         return FALSE;
2872 }
2873
2874
2875
2876
2877
2878 int
2879 STDCALL
2880 MulDiv (
2881         int     nNumber,
2882         int     nNumerator,
2883         int     nDenominator
2884         )
2885 {
2886         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2887         return 0;
2888 }
2889
2890
2891 int
2892 STDCALL
2893 MultiByteToWideChar (
2894         UINT    CodePage,
2895         DWORD   dwFlags,
2896         LPCSTR  lpMultiByteStr,
2897         int     cchMultiByte,
2898         LPWSTR  lpWideCharStr,
2899         int     cchWideChar
2900         )
2901 {
2902         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2903         return 0;
2904 }
2905
2906
2907 DWORD
2908 STDCALL
2909 OpenConsoleW (
2910         DWORD   Unknown0,
2911         DWORD   Unknown1,
2912         DWORD   Unknown2,
2913         DWORD   Unknown3
2914         )
2915 {
2916         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2917         return 0;
2918 }
2919
2920
2921 HANDLE
2922 STDCALL
2923 OpenMutexA (
2924         DWORD   dwDesiredAccess,
2925         WINBOOL bInheritHandle,
2926         LPCSTR  lpName
2927         )
2928 {
2929         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2930         return INVALID_HANDLE_VALUE;
2931 }
2932
2933
2934 HANDLE
2935 STDCALL
2936 OpenMutexW (
2937         DWORD   dwDesiredAccess,
2938         WINBOOL bInheritHandle,
2939         LPCWSTR lpName
2940         )
2941 {
2942         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2943         return INVALID_HANDLE_VALUE;
2944 }
2945
2946
2947 DWORD
2948 STDCALL
2949 OpenProfileUserMapping (VOID)
2950 {
2951         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2952         return 0;
2953 }
2954
2955
2956 HANDLE
2957 STDCALL
2958 OpenSemaphoreA (
2959         DWORD   dwDesiredAccess,
2960         WINBOOL bInheritHandle,
2961         LPCSTR  lpName
2962         )
2963 {
2964         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2965         return INVALID_HANDLE_VALUE;
2966 }
2967
2968
2969 HANDLE
2970 STDCALL
2971 OpenSemaphoreW (
2972         DWORD   dwDesiredAccess,
2973         WINBOOL bInheritHandle,
2974         LPCWSTR lpName
2975         )
2976 {
2977         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2978         return INVALID_HANDLE_VALUE;
2979 }
2980
2981
2982 WINBOOL
2983 STDCALL
2984 PeekNamedPipe (
2985         HANDLE  hNamedPipe,
2986         LPVOID  lpBuffer,
2987         DWORD   nBufferSize,
2988         LPDWORD lpBytesRead,
2989         LPDWORD lpTotalBytesAvail,
2990         LPDWORD lpBytesLeftThisMessage
2991         )
2992 {
2993         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2994         return FALSE;
2995 }
2996
2997
2998 DWORD
2999 STDCALL
3000 PrepareTape (
3001         HANDLE  hDevice,
3002         DWORD   dwOperation,
3003         WINBOOL bImmediate
3004         )
3005 {
3006         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3007         return 0;
3008 }
3009
3010
3011 WINBOOL
3012 STDCALL
3013 PurgeComm (
3014         HANDLE  hFile,
3015         DWORD   dwFlags
3016         )
3017 {
3018         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3019         return FALSE;
3020 }
3021
3022
3023 WINBOOL
3024 STDCALL
3025 QueryPerformanceCounter (
3026         LARGE_INTEGER   * lpPerformanceCount
3027         )
3028 {
3029         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3030         return FALSE;
3031 }
3032
3033
3034 WINBOOL
3035 STDCALL
3036 QueryPerformanceFrequency (
3037         LARGE_INTEGER   * lpFrequency
3038         )
3039 {
3040         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3041         return FALSE;
3042 }
3043
3044
3045 WINBOOL
3046 STDCALL
3047 QueryWin31IniFilesMappedToRegistry (
3048         DWORD   Unknown0,
3049         DWORD   Unknown1,
3050         DWORD   Unknown2,
3051         DWORD   Unknown3
3052         )
3053 {
3054         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3055         return FALSE;
3056 }
3057
3058
3059 VOID
3060 STDCALL
3061 RaiseException (
3062         DWORD           dwExceptionCode,
3063         DWORD           dwExceptionFlags,
3064         DWORD           nNumberOfArguments,
3065         CONST DWORD     * lpArguments
3066         )
3067 {
3068         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3069 }
3070
3071
3072
3073
3074
3075 WINBOOL
3076 STDCALL
3077 RegisterConsoleVDM (
3078         DWORD   Unknown0,
3079         DWORD   Unknown1,
3080         DWORD   Unknown2,
3081         DWORD   Unknown3,
3082         DWORD   Unknown4,
3083         DWORD   Unknown5,
3084         DWORD   Unknown6,
3085         DWORD   Unknown7,
3086         DWORD   Unknown8,
3087         DWORD   Unknown9,
3088         DWORD   Unknown10
3089         )
3090 {
3091         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3092         return FALSE;
3093 }
3094
3095
3096 WINBOOL
3097 STDCALL
3098 RegisterWowBaseHandlers (
3099         DWORD   Unknown0
3100         )
3101 {
3102         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3103         return FALSE;
3104 }
3105
3106
3107 WINBOOL
3108 STDCALL
3109 RegisterWowExec (
3110         DWORD   Unknown0
3111         )
3112 {
3113         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3114         return FALSE;
3115 }
3116
3117
3118 WINBOOL
3119 STDCALL
3120 ReleaseMutex (
3121         HANDLE  hMutex
3122         )
3123 {
3124         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3125         return FALSE;
3126 }
3127
3128
3129 WINBOOL
3130 STDCALL
3131 ReleaseSemaphore (
3132         HANDLE  hSemaphore,
3133         LONG    lReleaseCount,
3134         LPLONG  lpPreviousCount
3135         )
3136 {
3137         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3138         return FALSE;
3139 }
3140
3141
3142
3143
3144 WINBOOL
3145 STDCALL
3146 SetCommBreak (
3147         HANDLE  hFile
3148         )
3149 {
3150         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3151         return FALSE;
3152 }
3153
3154
3155 WINBOOL
3156 STDCALL
3157 SetCommConfig (
3158         HANDLE          hCommDev,
3159         LPCOMMCONFIG    lpCC,
3160         DWORD           dwSize
3161         )
3162 {
3163         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3164         return FALSE;
3165 }
3166
3167
3168 WINBOOL
3169 STDCALL
3170 SetCommMask (
3171         HANDLE  hFile,
3172         DWORD   dwEvtMask
3173         )
3174 {
3175         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3176         return FALSE;
3177 }
3178
3179
3180 WINBOOL
3181 STDCALL
3182 SetCommState (
3183         HANDLE  hFile,
3184         LPDCB   lpDCB
3185         )
3186 {
3187         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3188         return FALSE;
3189 }
3190
3191
3192 WINBOOL
3193 STDCALL
3194 SetCommTimeouts (
3195         HANDLE          hFile,
3196         LPCOMMTIMEOUTS  lpCommTimeouts
3197         )
3198 {
3199         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3200         return FALSE;
3201 }
3202
3203
3204 WINBOOL
3205 STDCALL
3206 SetComputerNameA (
3207         LPCSTR  lpComputerName
3208         )
3209 {
3210         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3211         return FALSE;
3212 }
3213
3214
3215 WINBOOL
3216 STDCALL
3217 SetComputerNameW (
3218     LPCWSTR lpComputerName
3219     )
3220 {
3221         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3222         return FALSE;
3223 }
3224
3225
3226 WINBOOL
3227 STDCALL
3228 SetConsoleCommandHistoryMode (
3229         DWORD   dwMode
3230         )
3231 {
3232         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3233         return FALSE;
3234 }
3235
3236
3237 WINBOOL
3238 STDCALL
3239 SetConsoleCursor (
3240         DWORD   Unknown0,
3241         DWORD   Unknown1
3242         )
3243 {
3244         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3245         return FALSE;
3246 }
3247
3248
3249 WINBOOL
3250 STDCALL
3251 SetConsoleDisplayMode (
3252         DWORD   Unknown0,
3253         DWORD   Unknown1,
3254         DWORD   Unknown2
3255         )
3256 {
3257         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3258         return FALSE;
3259 }
3260
3261
3262 WINBOOL
3263 STDCALL
3264 SetConsoleFont (
3265         DWORD   Unknown0,
3266         DWORD   Unknown1
3267         )
3268 {
3269         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3270         return FALSE;
3271 }
3272
3273
3274 WINBOOL
3275 STDCALL
3276 SetConsoleHardwareState (
3277         DWORD   Unknown0,
3278         DWORD   Unknown1,
3279         DWORD   Unknown2
3280         )
3281 {
3282         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3283         return FALSE;
3284 }
3285
3286
3287 WINBOOL
3288 STDCALL
3289 SetConsoleKeyShortcuts (
3290         DWORD   Unknown0,
3291         DWORD   Unknown1,
3292         DWORD   Unknown2,
3293         DWORD   Unknown3
3294         )
3295 {
3296         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3297         return FALSE;
3298 }
3299
3300
3301 WINBOOL
3302 STDCALL
3303 SetConsoleMaximumWindowSize (
3304         DWORD   Unknown0,
3305         DWORD   Unknown1
3306         )
3307 {
3308         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3309         return FALSE;
3310 }
3311
3312
3313 WINBOOL
3314 STDCALL
3315 SetConsoleMenuClose (
3316         DWORD   Unknown0
3317         )
3318 {
3319         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3320         return FALSE;
3321 }
3322
3323
3324 WINBOOL
3325 STDCALL
3326 SetConsoleNumberOfCommandsA (
3327         DWORD   Unknown0,
3328         DWORD   Unknown1
3329         )
3330 {
3331         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3332         return FALSE;
3333 }
3334
3335
3336 WINBOOL
3337 STDCALL
3338 SetConsoleNumberOfCommandsW (
3339         DWORD   Unknown0,
3340         DWORD   Unknown1
3341         )
3342 {
3343         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3344         return FALSE;
3345 }
3346
3347
3348 WINBOOL
3349 STDCALL
3350 SetConsolePalette (
3351         DWORD   Unknown0,
3352         DWORD   Unknown1,
3353         DWORD   Unknown2
3354         )
3355 {
3356         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3357         return FALSE;
3358 }
3359
3360
3361 WINBOOL
3362 STDCALL
3363 SetDefaultCommConfigA (
3364         LPCSTR          lpszName,
3365         LPCOMMCONFIG    lpCC,
3366         DWORD           dwSize
3367         )
3368 {
3369         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3370         return FALSE;
3371 }
3372
3373
3374 WINBOOL
3375 STDCALL
3376 SetDefaultCommConfigW (
3377         LPCWSTR         lpszName,
3378         LPCOMMCONFIG    lpCC,
3379         DWORD           dwSize
3380         )
3381 {
3382         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3383         return FALSE;
3384 }
3385
3386
3387 WINBOOL
3388 STDCALL
3389 SetLastConsoleEventActive (VOID)
3390 {
3391         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3392         return FALSE;
3393 }
3394
3395
3396 WINBOOL
3397 STDCALL
3398 SetLocaleInfoA (
3399         LCID    Locale,
3400         LCTYPE  LCType,
3401         LPCSTR  lpLCData
3402         )
3403 {
3404         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3405         return FALSE;
3406 }
3407
3408
3409 WINBOOL
3410 STDCALL
3411 SetLocaleInfoW (
3412         LCID    Locale,
3413         LCTYPE  LCType,
3414         LPCWSTR lpLCData
3415         )
3416 {
3417         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3418         return FALSE;
3419 }
3420
3421
3422 WINBOOL
3423 STDCALL
3424 SetMailslotInfo (
3425         HANDLE  hMailslot,
3426         DWORD   lReadTimeout
3427         )
3428 {
3429         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3430         return FALSE;
3431 }
3432
3433
3434 WINBOOL
3435 STDCALL
3436 SetNamedPipeHandleState (
3437         HANDLE  hNamedPipe,
3438         LPDWORD lpMode,
3439         LPDWORD lpMaxCollectionCount,
3440         LPDWORD lpCollectDataTimeout
3441         )
3442 {
3443         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3444         return FALSE;
3445 }
3446
3447
3448 WINBOOL
3449 STDCALL
3450 SetPriorityClass (
3451         HANDLE  hProcess,
3452         DWORD   dwPriorityClass
3453         )
3454 {
3455         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3456         return FALSE;
3457 }
3458
3459
3460 WINBOOL
3461 STDCALL
3462 SetProcessShutdownParameters (
3463         DWORD   dwLevel,
3464         DWORD   dwFlags
3465         )
3466 {
3467         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3468         return FALSE;
3469 }
3470
3471
3472 WINBOOL
3473 STDCALL
3474 SetProcessWorkingSetSize (
3475         HANDLE  hProcess,
3476         DWORD   dwMinimumWorkingSetSize,
3477         DWORD   dwMaximumWorkingSetSize
3478         )
3479 {
3480         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3481         return FALSE;
3482 }
3483
3484
3485 WINBOOL
3486 STDCALL
3487 SetSystemPowerState (
3488         DWORD   Unknown0,
3489         DWORD   Unknown1
3490         )
3491 {
3492         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3493         return FALSE;
3494 }
3495
3496
3497 DWORD
3498 STDCALL
3499 SetTapeParameters (
3500         HANDLE  hDevice,
3501         DWORD   dwOperation,
3502         LPVOID  lpTapeInformation
3503         )
3504 {
3505         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3506         return 0;
3507 }
3508
3509
3510 DWORD
3511 STDCALL
3512 SetTapePosition (
3513         HANDLE  hDevice,
3514         DWORD   dwPositionMethod,
3515         DWORD   dwPartition,
3516         DWORD   dwOffsetLow,
3517         DWORD   dwOffsetHigh,
3518         WINBOOL bImmediate
3519         )
3520 {
3521         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3522         return FALSE;
3523 }
3524
3525
3526 WINBOOL
3527 STDCALL
3528 SetThreadLocale (
3529         LCID    Locale
3530         )
3531 {
3532         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3533         return FALSE;
3534 }
3535
3536
3537 WINBOOL
3538 STDCALL
3539 SetVDMCurrentDirectories (
3540         DWORD   Unknown0,
3541         DWORD   Unknown1
3542         )
3543 {
3544         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3545         return FALSE;
3546 }
3547
3548
3549 WINBOOL
3550 STDCALL
3551 SetupComm (
3552         HANDLE  hFile,
3553         DWORD   dwInQueue,
3554         DWORD   dwOutQueue
3555         )
3556 {
3557         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3558         return FALSE;
3559 }
3560
3561
3562 DWORD
3563 STDCALL
3564 ShowConsoleCursor (
3565         DWORD   Unknown0,
3566         DWORD   Unknown1
3567         )
3568 {
3569         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3570         return 0;
3571 }
3572
3573
3574
3575
3576
3577
3578
3579 LPVOID
3580 STDCALL
3581 TlsGetValue (
3582         DWORD   dwTlsIndex
3583         )
3584 {
3585         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3586         return NULL;
3587 }
3588
3589
3590 WINBOOL
3591 STDCALL
3592 TransactNamedPipe (
3593         HANDLE          hNamedPipe,
3594         LPVOID          lpInBuffer,
3595         DWORD           nInBufferSize,
3596         LPVOID          lpOutBuffer,
3597         DWORD           nOutBufferSize,
3598         LPDWORD         lpBytesRead,
3599         LPOVERLAPPED    lpOverlapped
3600         )
3601 {
3602         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3603         return FALSE;
3604 }
3605
3606
3607 WINBOOL
3608 STDCALL
3609 TransmitCommChar (
3610         HANDLE  hFile,
3611         char    cChar
3612         )
3613 {
3614         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3615         return FALSE;
3616 }
3617
3618
3619 DWORD
3620 STDCALL
3621 TrimVirtualBuffer (
3622         DWORD   Unknown0
3623         )
3624 {
3625         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3626         return 0;
3627 }
3628
3629
3630 WINBOOL
3631 STDCALL
3632 UpdateResourceA (
3633         HANDLE  hUpdate,
3634         LPCSTR  lpType,
3635         LPCSTR  lpName,
3636         WORD    wLanguage,
3637         LPVOID  lpData,
3638         DWORD   cbData
3639         )
3640 {
3641         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3642         return FALSE;
3643 }
3644
3645
3646 WINBOOL
3647 STDCALL
3648 UpdateResourceW (
3649         HANDLE  hUpdate,
3650         LPCWSTR lpType,
3651         LPCWSTR lpName,
3652         WORD    wLanguage,
3653         LPVOID  lpData,
3654         DWORD   cbData
3655         )
3656 {
3657         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3658         return FALSE;
3659 }
3660
3661
3662 DWORD
3663 STDCALL
3664 VDMConsoleOperation (
3665         DWORD   Unknown0,
3666         DWORD   Unknown1
3667         )
3668 {
3669         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3670         return 0;
3671 }
3672
3673
3674 DWORD
3675 STDCALL
3676 VDMOperationStarted (
3677         DWORD   Unknown0
3678         )
3679 {
3680         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3681         return 0;
3682 }
3683
3684
3685 DWORD
3686 STDCALL
3687 VerLanguageNameA (
3688         DWORD   wLang,
3689         LPSTR   szLang,
3690         DWORD   nSize
3691         )
3692 {
3693         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3694         return 0;
3695 }
3696
3697
3698 DWORD
3699 STDCALL
3700 VerLanguageNameW (
3701         DWORD   wLang,
3702         LPWSTR  szLang,
3703         DWORD   nSize
3704         )
3705 {
3706         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3707         return 0;
3708 }
3709
3710
3711 DWORD
3712 STDCALL
3713 VerifyConsoleIoHandle (
3714         DWORD   Unknown0
3715         )
3716 {
3717         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3718         return 0;
3719 }
3720
3721
3722 DWORD
3723 STDCALL
3724 VirtualBufferExceptionHandler (
3725         DWORD   Unknown0,
3726         DWORD   Unknown1,
3727         DWORD   Unknown2
3728         )
3729 {
3730         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3731         return 0;
3732 }
3733
3734
3735 WINBOOL
3736 STDCALL
3737 WaitCommEvent (
3738         HANDLE          hFile,
3739         LPDWORD         lpEvtMask,
3740         LPOVERLAPPED    lpOverlapped
3741         )
3742 {
3743         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3744         return FALSE;
3745 }
3746
3747
3748 WINBOOL
3749 STDCALL
3750 WaitForDebugEvent (
3751         LPDEBUG_EVENT   lpDebugEvent,
3752         DWORD           dwMilliseconds
3753         )
3754 {
3755         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3756         return FALSE;
3757 }
3758
3759
3760 WINBOOL
3761 STDCALL
3762 WaitNamedPipeA (
3763         LPCSTR  lpNamedPipeName,
3764         DWORD   nTimeOut
3765         )
3766 {
3767         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3768         return FALSE;
3769 }
3770
3771
3772 WINBOOL
3773 STDCALL
3774 WaitNamedPipeW (
3775         LPCWSTR lpNamedPipeName,
3776         DWORD   nTimeOut
3777         )
3778 {
3779         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3780         return FALSE;
3781 }
3782
3783
3784 int
3785 STDCALL
3786 WideCharToMultiByte (
3787         UINT    CodePage,
3788         DWORD   dwFlags,
3789         LPCWSTR lpWideCharStr,
3790         int     cchWideChar,
3791         LPSTR   lpMultiByteStr,
3792         int     cchMultiByte,
3793         LPCSTR  lpDefaultChar,
3794         LPBOOL  lpUsedDefaultChar
3795         )
3796 {
3797         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3798         return FALSE;
3799 }
3800
3801
3802 DWORD
3803 STDCALL
3804 WriteConsoleInputVDMA (
3805         DWORD   Unknown0,
3806         DWORD   Unknown1,
3807         DWORD   Unknown2,
3808         DWORD   Unknown3
3809         )
3810 {
3811         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3812         return 0;
3813 }
3814
3815
3816 DWORD
3817 STDCALL
3818 WriteConsoleInputVDMW (
3819         DWORD   Unknown0,
3820         DWORD   Unknown1,
3821         DWORD   Unknown2,
3822         DWORD   Unknown3
3823         )
3824 {
3825         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3826         return 0;
3827 }
3828
3829
3830 WINBOOL
3831 STDCALL
3832 WritePrivateProfileSectionA (
3833         LPCSTR  lpAppName,
3834         LPCSTR  lpString,
3835         LPCSTR  lpFileName
3836         )
3837 {
3838         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3839         return FALSE;
3840 }
3841
3842
3843 WINBOOL
3844 STDCALL
3845 WritePrivateProfileSectionW (
3846         LPCWSTR lpAppName,
3847         LPCWSTR lpString,
3848         LPCWSTR lpFileName
3849         )
3850 {
3851         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3852         return FALSE;
3853 }
3854
3855
3856 WINBOOL
3857 STDCALL
3858 WritePrivateProfileStringA (
3859         LPCSTR  lpAppName,
3860         LPCSTR  lpKeyName,
3861         LPCSTR  lpString,
3862         LPCSTR  lpFileName
3863         )
3864 {
3865         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3866         return FALSE;
3867 }
3868
3869
3870 WINBOOL
3871 STDCALL
3872 WritePrivateProfileStringW (
3873         LPCWSTR lpAppName,
3874         LPCWSTR lpKeyName,
3875         LPCWSTR lpString,
3876         LPCWSTR lpFileName
3877         )
3878 {
3879         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3880         return FALSE;
3881 }
3882
3883
3884 WINBOOL
3885 STDCALL
3886 WritePrivateProfileStructA (
3887         DWORD   Unknown0,
3888         DWORD   Unknown1,
3889         DWORD   Unknown2,
3890         DWORD   Unknown3,
3891         DWORD   Unknown4
3892         )
3893 {
3894         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3895         return FALSE;
3896 }
3897
3898
3899 WINBOOL
3900 STDCALL
3901 WritePrivateProfileStructW (
3902         DWORD   Unknown0,
3903         DWORD   Unknown1,
3904         DWORD   Unknown2,
3905         DWORD   Unknown3,
3906         DWORD   Unknown4
3907         )
3908 {
3909         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3910         return FALSE;
3911 }
3912
3913
3914
3915
3916 WINBOOL
3917 STDCALL
3918 WriteProfileSectionA (
3919         LPCSTR  lpAppName,
3920         LPCSTR  lpString
3921         )
3922 {
3923         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3924         return FALSE;
3925 }
3926
3927
3928 WINBOOL
3929 STDCALL
3930 WriteProfileSectionW (
3931         LPCWSTR lpAppName,
3932         LPCWSTR lpString
3933         )
3934 {
3935         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3936         return FALSE;
3937 }
3938
3939
3940 WINBOOL
3941 STDCALL
3942 WriteProfileStringA (
3943         LPCSTR  lpAppName,
3944         LPCSTR  lpKeyName,
3945         LPCSTR  lpString
3946         )
3947 {
3948         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3949         return FALSE;
3950 }
3951
3952
3953 WINBOOL
3954 STDCALL
3955 WriteProfileStringW (
3956         LPCWSTR lpAppName,
3957         LPCWSTR lpKeyName,
3958         LPCWSTR lpString
3959         )
3960 {
3961         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3962         return FALSE;
3963 }
3964
3965
3966 DWORD
3967 STDCALL
3968 WriteTapemark (
3969         HANDLE  hDevice,
3970         DWORD   dwTapemarkType,
3971         DWORD   dwTapemarkCount,
3972         WINBOOL bImmediate
3973         )
3974 {
3975         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3976         return 0;
3977 }
3978
3979 DWORD
3980 STDCALL
3981 GetTapePosition (
3982         HANDLE  hDevice,
3983         DWORD   dwPositionType,
3984         LPDWORD lpdwPartition,
3985         LPDWORD lpdwOffsetLow,
3986         LPDWORD lpdwOffsetHigh
3987         )
3988 {
3989         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3990         return 0;
3991 }
3992
3993
3994
3995 /* EOF */