reactos/lib/kernel32/misc/stubs.c

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