reactos/lib/kernel32/misc/stubs.c

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