reactos/lib/kernel32/misc/stubs.c

   1 /* $Id: stubs.c,v 1.22 2000/09/05 13:52:04 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 HGLOBAL
2190 STDCALL
2191 GlobalFree (
2192         HGLOBAL hMem
2193         )
2194 {
2195         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2196         return hMem;
2197 }
2198
2199
2200 UINT
2201 STDCALL
2202 GlobalGetAtomNameA (
2203         ATOM    nAtom,
2204         LPSTR   lpBuffer,
2205         int     nSize
2206         )
2207 {
2208         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2209         return 0;
2210 }
2211
2212
2213 UINT
2214 STDCALL
2215 GlobalGetAtomNameW (
2216         ATOM    nAtom,
2217         LPWSTR  lpBuffer,
2218         int     nSize
2219         )
2220 {
2221         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2222         return 0;
2223 }
2224
2225
2226 HGLOBAL
2227 STDCALL
2228 GlobalHandle (
2229         LPCVOID pMem
2230         )
2231 {
2232         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2233         return 0;
2234 }
2235
2236
2237 LPVOID
2238 STDCALL
2239 GlobalLock (
2240         HGLOBAL hMem
2241         )
2242 {
2243         /* In Win32 GlobalAlloc returns LPVOID? */
2244         return hMem;
2245 }
2246
2247
2248 VOID
2249 STDCALL
2250 GlobalMemoryStatus (
2251         LPMEMORYSTATUS  lpBuffer
2252         )
2253 {
2254         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2255 }
2256
2257
2258 HGLOBAL
2259 STDCALL
2260 GlobalReAlloc (
2261         HGLOBAL hMem,
2262         DWORD   dwBytes,
2263         UINT    uFlags
2264         )
2265 {
2266         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2267         return 0;
2268 }
2269
2270
2271 DWORD
2272 STDCALL
2273 GlobalSize (
2274         HGLOBAL hMem
2275         )
2276 {
2277         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2278         return 0;
2279 }
2280
2281
2282 WINBOOL
2283 STDCALL
2284 GlobalUnWire (
2285         HGLOBAL hMem
2286         )
2287 {
2288         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2289         return FALSE;
2290 }
2291
2292
2293 VOID
2294 STDCALL
2295 GlobalUnfix (
2296         HGLOBAL hMem
2297         )
2298 {
2299         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2300 }
2301
2302
2303 WINBOOL
2304 STDCALL
2305 GlobalUnlock (
2306         HGLOBAL hMem
2307         )
2308 {
2309         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2310         return FALSE;
2311 }
2312
2313
2314 LPVOID
2315 STDCALL
2316 GlobalWire (
2317         HGLOBAL hMem
2318         )
2319 {
2320         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2321         return NULL; /* ? */
2322 }
2323
2324
2325 DWORD
2326 STDCALL
2327 HeapCreateTagsW (
2328         DWORD   Unknown0,
2329         DWORD   Unknown1,
2330         DWORD   Unknown2,
2331         DWORD   Unknown3
2332         )
2333 {
2334         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2335         return 0;
2336 }
2337
2338
2339 DWORD
2340 STDCALL
2341 HeapExtend (
2342         DWORD   Unknown0,
2343         DWORD   Unknown1,
2344         DWORD   Unknown2,
2345         DWORD   Unknown3
2346         )
2347 {
2348         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2349         return 0;
2350 }
2351
2352
2353 DWORD
2354 STDCALL
2355 HeapQueryTagW (
2356         DWORD   Unknown0,
2357         DWORD   Unknown1,
2358         DWORD   Unknown2,
2359         DWORD   Unknown3,
2360         DWORD   Unknown4
2361         )
2362 {
2363         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2364         return 0;
2365 }
2366
2367
2368 DWORD
2369 STDCALL
2370 HeapSummary (
2371         DWORD   Unknown0,
2372         DWORD   Unknown1,
2373         DWORD   Unknown2
2374         )
2375 {
2376         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2377         return 0;
2378 }
2379
2380
2381 DWORD
2382 STDCALL
2383 HeapUsage (
2384         DWORD   Unknown0,
2385         DWORD   Unknown1,
2386         DWORD   Unknown2,
2387         DWORD   Unknown3,
2388         DWORD   Unknown4
2389         )
2390 {
2391         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2392         return 0;
2393 }
2394
2395
2396 WINBOOL
2397 STDCALL
2398 HeapWalk (
2399         HANDLE                  hHeap,
2400         LPPROCESS_HEAP_ENTRY    lpEntry
2401         )
2402 {
2403         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2404         return FALSE;
2405 }
2406
2407
2408 WINBOOL
2409 STDCALL
2410 InitAtomTable (
2411         DWORD nSize
2412         )
2413 {
2414         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2415         return FALSE;
2416 }
2417
2418
2419 DWORD
2420 STDCALL
2421 InvalidateConsoleDIBits (
2422         DWORD   Unknown0,
2423         DWORD   Unknown1
2424         )
2425 {
2426         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2427         return 0;
2428 }
2429
2430
2431 WINBOOL
2432 STDCALL
2433 IsDBCSLeadByte (
2434         BYTE    TestChar
2435         )
2436 {
2437         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2438         return FALSE;
2439 }
2440
2441
2442 WINBOOL
2443 STDCALL
2444 IsDBCSLeadByteEx (
2445         UINT    CodePage,
2446         BYTE    TestChar
2447         )
2448 {
2449         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2450         return FALSE;
2451 }
2452
2453
2454 WINBOOL
2455 STDCALL
2456 IsValidCodePage (
2457         UINT    CodePage
2458         )
2459 {
2460         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2461         return FALSE;
2462 }
2463
2464
2465 WINBOOL
2466 STDCALL
2467 IsValidLocale (
2468         LCID    Locale,
2469         DWORD   dwFlags
2470         )
2471 {
2472         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2473         return FALSE;
2474 }
2475
2476
2477 int
2478 STDCALL
2479 LCMapStringA (
2480         LCID    Locale,
2481         DWORD   dwMapFlags,
2482         LPCSTR  lpSrcStr,
2483         int     cchSrc,
2484         LPSTR   lpDestStr,
2485         int     cchDest
2486         )
2487 {
2488         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2489         return 0;
2490 }
2491
2492
2493 int
2494 STDCALL
2495 LCMapStringW (
2496         LCID    Locale,
2497         DWORD   dwMapFlags,
2498         LPCWSTR lpSrcStr,
2499         int     cchSrc,
2500         LPWSTR  lpDestStr,
2501         int     cchDest
2502         )
2503 {
2504         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2505         return 0;
2506 }
2507
2508
2509 DWORD
2510 STDCALL
2511 LoadModule (
2512         LPCSTR  lpModuleName,
2513         LPVOID  lpParameterBlock
2514         )
2515 {
2516         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2517         return 0;
2518 }
2519
2520
2521
2522
2523
2524 HLOCAL
2525 STDCALL
2526 LocalAlloc (
2527         UINT    uFlags,
2528         UINT    uBytes
2529         )
2530 {
2531         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2532         return 0;
2533 }
2534
2535
2536 UINT
2537 STDCALL
2538 LocalCompact (
2539         UINT    uMinFree
2540         )
2541 {
2542         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2543         return 0;
2544 }
2545
2546
2547 UINT
2548 STDCALL
2549 LocalFlags (
2550         HLOCAL  hMem
2551         )
2552 {
2553         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2554         return 0;
2555 }
2556
2557
2558 HLOCAL
2559 STDCALL
2560 LocalFree (
2561         HLOCAL  hMem
2562         )
2563 {
2564         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2565         return hMem;
2566 }
2567
2568
2569 HLOCAL
2570 STDCALL
2571 LocalHandle (
2572         LPCVOID pMem
2573         )
2574 {
2575         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2576         return 0;
2577 }
2578
2579
2580 LPVOID
2581 STDCALL
2582 LocalLock (
2583         HLOCAL  hMem
2584         )
2585 {
2586         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2587         return NULL;
2588 }
2589
2590
2591 HLOCAL
2592 STDCALL
2593 LocalReAlloc (
2594         HLOCAL  hMem,
2595         UINT    uBytes,
2596         UINT    uFlags
2597         )
2598 {
2599         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2600         return 0;
2601 }
2602
2603
2604 UINT
2605 STDCALL
2606 LocalShrink (
2607         HLOCAL  hMem,
2608         UINT    cbNewSize
2609         )
2610 {
2611         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2612         return 0;
2613 }
2614
2615
2616 UINT
2617 STDCALL
2618 LocalSize (
2619         HLOCAL  hMem
2620         )
2621 {
2622         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2623         return 0;
2624 }
2625
2626
2627 WINBOOL
2628 STDCALL
2629 LocalUnlock (
2630         HLOCAL  hMem
2631         )
2632 {
2633         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2634         return FALSE;
2635 }
2636
2637
2638
2639
2640
2641 int
2642 STDCALL
2643 MulDiv (
2644         int     nNumber,
2645         int     nNumerator,
2646         int     nDenominator
2647         )
2648 {
2649         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2650         return 0;
2651 }
2652
2653
2654 /**********************************************************************
2655  * NAME                                                 PRIVATE
2656  *      IsInstalledCP@4
2657  *
2658  * RETURN VALUE
2659  *      TRUE if CodePage is installed in the system.
2660  */
2661 static
2662 BOOL
2663 STDCALL
2664 IsInstalledCP (
2665         UINT    CodePage
2666         )
2667 {
2668         /* FIXME */
2669         return TRUE;
2670 }
2671
2672
2673 /**********************************************************************
2674  * NAME                                                 EXPORTED
2675  *      MultiByteToWideChar@24
2676  *
2677  * ARGUMENTS
2678  *      CodePage
2679  *              CP_ACP          ANSI code page
2680  *              CP_MACCP        Macintosh code page
2681  *              CP_OEMCP        OEM code page
2682  *              (UINT)          Any installed code page
2683  *
2684  *      dwFlags
2685  *              MB_PRECOMPOSED
2686  *              MB_COMPOSITE
2687  *              MB_ERR_INVALID_CHARS
2688  *              MB_USEGLYPHCHARS
2689  *
2690  *      lpMultiByteStr
2691  *              Input buffer;
2692  *
2693  *      cchMultiByte
2694  *              Size of MultiByteStr, or -1 if MultiByteStr is
2695  *              NULL terminated;
2696  *
2697  *      lpWideCharStr
2698  *              Output buffer;
2699  *
2700  *      cchWideChar
2701  *              Size (in WCHAR unit) of WideCharStr, or 0
2702  *              if the caller just wants to know how large
2703  *              WideCharStr should be for a successful
2704  *              conversion.
2705  *
2706  * RETURN VALUE
2707  *      0 on error; otherwise the number of WCHAR written
2708  *      in the WideCharStr buffer.
2709  *
2710  * NOTE
2711  *      A raw converter for now. It assumes lpMultiByteStr is
2712  *      NEVER multi-byte (that is each input character is
2713  *      8-bit ASCII) and is ALWAYS NULL terminated.
2714  *      FIXME-FIXME-FIXME-FIXME
2715  */
2716 INT
2717 STDCALL
2718 MultiByteToWideChar (
2719         UINT    CodePage,
2720         DWORD   dwFlags,
2721         LPCSTR  lpMultiByteStr,
2722         int     cchMultiByte,
2723         LPWSTR  lpWideCharStr,
2724         int     cchWideChar
2725         )
2726 {
2727         int     InStringLength = 0;
2728         BOOL    InIsNullTerminated = TRUE;
2729         PCHAR   r;
2730         PWCHAR  w;
2731         int     cchConverted;
2732
2733         /*
2734          * Check the parameters.
2735          */
2736         if (    /* --- CODE PAGE --- */
2737                 (       (CP_ACP != CodePage)
2738                         && (CP_MACCP != CodePage)
2739                         && (CP_OEMCP != CodePage)
2740                         && (FALSE == IsInstalledCP (CodePage))
2741                         )
2742                 /* --- FLAGS --- */
2743                 || (dwFlags ^ ( MB_PRECOMPOSED
2744                                 | MB_COMPOSITE
2745                                 | MB_ERR_INVALID_CHARS
2746                                 | MB_USEGLYPHCHARS
2747                                 )
2748                         )
2749                 /* --- INPUT BUFFER --- */
2750                 || (NULL == lpMultiByteStr)
2751                 )
2752         {
2753                 SetLastError (ERROR_INVALID_PARAMETER);
2754                 return 0;
2755         }
2756         /*
2757          * Compute the input buffer length.
2758          */
2759         if (-1 == cchMultiByte)
2760         {
2761                 InStringLength = lstrlen (lpMultiByteStr);
2762         }
2763         else
2764         {
2765                 InIsNullTerminated = FALSE;
2766                 InStringLength = cchMultiByte;
2767         }
2768         /*
2769          * Does caller query for output
2770          * buffer size?
2771          */
2772         if (0 == cchWideChar)
2773         {
2774                 SetLastError (ERROR_SUCCESS);
2775                 return InStringLength;
2776         }
2777         /*
2778          * Is space provided for the translated
2779          * string enough?
2780          */
2781         if (cchWideChar < InStringLength)
2782         {
2783                 SetLastError (ERROR_INSUFFICIENT_BUFFER);
2784                 return 0;
2785         }
2786         /*
2787          * Raw 8- to 16-bit conversion.
2788          */
2789         for (   cchConverted = 0,
2790                 r = (PCHAR) lpMultiByteStr,
2791                 w = (PWCHAR) lpWideCharStr;
2792
2793                 ((*r) && (cchConverted < cchWideChar));
2794
2795                 r++,
2796                 cchConverted++
2797                 )
2798         {
2799                 *w = (WCHAR) *r;
2800         }
2801         /*
2802          * Is the input string NULL terminated?
2803          */
2804         if (TRUE == InIsNullTerminated)
2805         {
2806                 *w = L'\0';
2807                 ++cchConverted;
2808         }
2809         /*
2810          * Return how many characters we
2811          * wrote in the output buffer.
2812          */
2813         SetLastError (ERROR_SUCCESS);
2814         return cchConverted;
2815 }
2816
2817
2818 DWORD
2819 STDCALL
2820 OpenConsoleW (
2821         DWORD   Unknown0,
2822         DWORD   Unknown1,
2823         DWORD   Unknown2,
2824         DWORD   Unknown3
2825         )
2826 {
2827         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2828         return 0;
2829 }
2830
2831
2832 HANDLE
2833 STDCALL
2834 OpenMutexA (
2835         DWORD   dwDesiredAccess,
2836         WINBOOL bInheritHandle,
2837         LPCSTR  lpName
2838         )
2839 {
2840         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2841         return INVALID_HANDLE_VALUE;
2842 }
2843
2844
2845 HANDLE
2846 STDCALL
2847 OpenMutexW (
2848         DWORD   dwDesiredAccess,
2849         WINBOOL bInheritHandle,
2850         LPCWSTR lpName
2851         )
2852 {
2853         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2854         return INVALID_HANDLE_VALUE;
2855 }
2856
2857
2858 DWORD
2859 STDCALL
2860 OpenProfileUserMapping (VOID)
2861 {
2862         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2863         return 0;
2864 }
2865
2866
2867 HANDLE
2868 STDCALL
2869 OpenSemaphoreA (
2870         DWORD   dwDesiredAccess,
2871         WINBOOL bInheritHandle,
2872         LPCSTR  lpName
2873         )
2874 {
2875         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2876         return INVALID_HANDLE_VALUE;
2877 }
2878
2879
2880 HANDLE
2881 STDCALL
2882 OpenSemaphoreW (
2883         DWORD   dwDesiredAccess,
2884         WINBOOL bInheritHandle,
2885         LPCWSTR lpName
2886         )
2887 {
2888         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2889         return INVALID_HANDLE_VALUE;
2890 }
2891
2892
2893 WINBOOL
2894 STDCALL
2895 PeekNamedPipe (
2896         HANDLE  hNamedPipe,
2897         LPVOID  lpBuffer,
2898         DWORD   nBufferSize,
2899         LPDWORD lpBytesRead,
2900         LPDWORD lpTotalBytesAvail,
2901         LPDWORD lpBytesLeftThisMessage
2902         )
2903 {
2904         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2905         return FALSE;
2906 }
2907
2908
2909 DWORD
2910 STDCALL
2911 PrepareTape (
2912         HANDLE  hDevice,
2913         DWORD   dwOperation,
2914         WINBOOL bImmediate
2915         )
2916 {
2917         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2918         return 0;
2919 }
2920
2921
2922 WINBOOL
2923 STDCALL
2924 PurgeComm (
2925         HANDLE  hFile,
2926         DWORD   dwFlags
2927         )
2928 {
2929         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2930         return FALSE;
2931 }
2932
2933
2934 WINBOOL
2935 STDCALL
2936 QueryPerformanceCounter (
2937         LARGE_INTEGER   * lpPerformanceCount
2938         )
2939 {
2940         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2941         return FALSE;
2942 }
2943
2944
2945 WINBOOL
2946 STDCALL
2947 QueryPerformanceFrequency (
2948         LARGE_INTEGER   * lpFrequency
2949         )
2950 {
2951         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2952         return FALSE;
2953 }
2954
2955
2956 WINBOOL
2957 STDCALL
2958 QueryWin31IniFilesMappedToRegistry (
2959         DWORD   Unknown0,
2960         DWORD   Unknown1,
2961         DWORD   Unknown2,
2962         DWORD   Unknown3
2963         )
2964 {
2965         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2966         return FALSE;
2967 }
2968
2969
2970 VOID
2971 STDCALL
2972 RaiseException (
2973         DWORD           dwExceptionCode,
2974         DWORD           dwExceptionFlags,
2975         DWORD           nNumberOfArguments,
2976         CONST DWORD     * lpArguments
2977         )
2978 {
2979         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2980 }
2981
2982
2983
2984
2985
2986 WINBOOL
2987 STDCALL
2988 RegisterConsoleVDM (
2989         DWORD   Unknown0,
2990         DWORD   Unknown1,
2991         DWORD   Unknown2,
2992         DWORD   Unknown3,
2993         DWORD   Unknown4,
2994         DWORD   Unknown5,
2995         DWORD   Unknown6,
2996         DWORD   Unknown7,
2997         DWORD   Unknown8,
2998         DWORD   Unknown9,
2999         DWORD   Unknown10
3000         )
3001 {
3002         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3003         return FALSE;
3004 }
3005
3006
3007 WINBOOL
3008 STDCALL
3009 RegisterWowBaseHandlers (
3010         DWORD   Unknown0
3011         )
3012 {
3013         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3014         return FALSE;
3015 }
3016
3017
3018 WINBOOL
3019 STDCALL
3020 RegisterWowExec (
3021         DWORD   Unknown0
3022         )
3023 {
3024         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3025         return FALSE;
3026 }
3027
3028
3029 WINBOOL
3030 STDCALL
3031 ReleaseMutex (
3032         HANDLE  hMutex
3033         )
3034 {
3035         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3036         return FALSE;
3037 }
3038
3039
3040 WINBOOL
3041 STDCALL
3042 ReleaseSemaphore (
3043         HANDLE  hSemaphore,
3044         LONG    lReleaseCount,
3045         LPLONG  lpPreviousCount
3046         )
3047 {
3048         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3049         return FALSE;
3050 }
3051
3052
3053
3054
3055 WINBOOL
3056 STDCALL
3057 SetCommBreak (
3058         HANDLE  hFile
3059         )
3060 {
3061         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3062         return FALSE;
3063 }
3064
3065
3066 WINBOOL
3067 STDCALL
3068 SetCommConfig (
3069         HANDLE          hCommDev,
3070         LPCOMMCONFIG    lpCC,
3071         DWORD           dwSize
3072         )
3073 {
3074         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3075         return FALSE;
3076 }
3077
3078
3079 WINBOOL
3080 STDCALL
3081 SetCommMask (
3082         HANDLE  hFile,
3083         DWORD   dwEvtMask
3084         )
3085 {
3086         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3087         return FALSE;
3088 }
3089
3090
3091 WINBOOL
3092 STDCALL
3093 SetCommState (
3094         HANDLE  hFile,
3095         LPDCB   lpDCB
3096         )
3097 {
3098         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3099         return FALSE;
3100 }
3101
3102
3103 WINBOOL
3104 STDCALL
3105 SetCommTimeouts (
3106         HANDLE          hFile,
3107         LPCOMMTIMEOUTS  lpCommTimeouts
3108         )
3109 {
3110         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3111         return FALSE;
3112 }
3113
3114
3115 WINBOOL
3116 STDCALL
3117 SetComputerNameA (
3118         LPCSTR  lpComputerName
3119         )
3120 {
3121         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3122         return FALSE;
3123 }
3124
3125
3126 WINBOOL
3127 STDCALL
3128 SetComputerNameW (
3129     LPCWSTR lpComputerName
3130     )
3131 {
3132         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3133         return FALSE;
3134 }
3135
3136
3137 WINBOOL
3138 STDCALL
3139 SetConsoleCommandHistoryMode (
3140         DWORD   dwMode
3141         )
3142 {
3143         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3144         return FALSE;
3145 }
3146
3147
3148 WINBOOL
3149 STDCALL
3150 SetConsoleCursor (
3151         DWORD   Unknown0,
3152         DWORD   Unknown1
3153         )
3154 {
3155         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3156         return FALSE;
3157 }
3158
3159
3160 WINBOOL
3161 STDCALL
3162 SetConsoleDisplayMode (
3163         DWORD   Unknown0,
3164         DWORD   Unknown1,
3165         DWORD   Unknown2
3166         )
3167 {
3168         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3169         return FALSE;
3170 }
3171
3172
3173 WINBOOL
3174 STDCALL
3175 SetConsoleFont (
3176         DWORD   Unknown0,
3177         DWORD   Unknown1
3178         )
3179 {
3180         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3181         return FALSE;
3182 }
3183
3184
3185 WINBOOL
3186 STDCALL
3187 SetConsoleHardwareState (
3188         DWORD   Unknown0,
3189         DWORD   Unknown1,
3190         DWORD   Unknown2
3191         )
3192 {
3193         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3194         return FALSE;
3195 }
3196
3197
3198 WINBOOL
3199 STDCALL
3200 SetConsoleKeyShortcuts (
3201         DWORD   Unknown0,
3202         DWORD   Unknown1,
3203         DWORD   Unknown2,
3204         DWORD   Unknown3
3205         )
3206 {
3207         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3208         return FALSE;
3209 }
3210
3211
3212 WINBOOL
3213 STDCALL
3214 SetConsoleMaximumWindowSize (
3215         DWORD   Unknown0,
3216         DWORD   Unknown1
3217         )
3218 {
3219         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3220         return FALSE;
3221 }
3222
3223
3224 WINBOOL
3225 STDCALL
3226 SetConsoleMenuClose (
3227         DWORD   Unknown0
3228         )
3229 {
3230         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3231         return FALSE;
3232 }
3233
3234
3235 WINBOOL
3236 STDCALL
3237 SetConsoleNumberOfCommandsA (
3238         DWORD   Unknown0,
3239         DWORD   Unknown1
3240         )
3241 {
3242         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3243         return FALSE;
3244 }
3245
3246
3247 WINBOOL
3248 STDCALL
3249 SetConsoleNumberOfCommandsW (
3250         DWORD   Unknown0,
3251         DWORD   Unknown1
3252         )
3253 {
3254         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3255         return FALSE;
3256 }
3257
3258
3259 WINBOOL
3260 STDCALL
3261 SetConsolePalette (
3262         DWORD   Unknown0,
3263         DWORD   Unknown1,
3264         DWORD   Unknown2
3265         )
3266 {
3267         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3268         return FALSE;
3269 }
3270
3271
3272 WINBOOL
3273 STDCALL
3274 SetDefaultCommConfigA (
3275         LPCSTR          lpszName,
3276         LPCOMMCONFIG    lpCC,
3277         DWORD           dwSize
3278         )
3279 {
3280         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3281         return FALSE;
3282 }
3283
3284
3285 WINBOOL
3286 STDCALL
3287 SetDefaultCommConfigW (
3288         LPCWSTR         lpszName,
3289         LPCOMMCONFIG    lpCC,
3290         DWORD           dwSize
3291         )
3292 {
3293         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3294         return FALSE;
3295 }
3296
3297
3298 WINBOOL
3299 STDCALL
3300 SetLastConsoleEventActive (VOID)
3301 {
3302         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3303         return FALSE;
3304 }
3305
3306
3307 WINBOOL
3308 STDCALL
3309 SetLocaleInfoA (
3310         LCID    Locale,
3311         LCTYPE  LCType,
3312         LPCSTR  lpLCData
3313         )
3314 {
3315         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3316         return FALSE;
3317 }
3318
3319
3320 WINBOOL
3321 STDCALL
3322 SetLocaleInfoW (
3323         LCID    Locale,
3324         LCTYPE  LCType,
3325         LPCWSTR lpLCData
3326         )
3327 {
3328         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3329         return FALSE;
3330 }
3331
3332
3333 WINBOOL
3334 STDCALL
3335 SetMailslotInfo (
3336         HANDLE  hMailslot,
3337         DWORD   lReadTimeout
3338         )
3339 {
3340         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3341         return FALSE;
3342 }
3343
3344
3345
3346
3347 WINBOOL
3348 STDCALL
3349 SetProcessShutdownParameters (
3350         DWORD   dwLevel,
3351         DWORD   dwFlags
3352         )
3353 {
3354         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3355         return FALSE;
3356 }
3357
3358
3359 WINBOOL
3360 STDCALL
3361 SetProcessWorkingSetSize (
3362         HANDLE  hProcess,
3363         DWORD   dwMinimumWorkingSetSize,
3364         DWORD   dwMaximumWorkingSetSize
3365         )
3366 {
3367         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3368         return FALSE;
3369 }
3370
3371
3372 WINBOOL
3373 STDCALL
3374 SetSystemPowerState (
3375         DWORD   Unknown0,
3376         DWORD   Unknown1
3377         )
3378 {
3379         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3380         return FALSE;
3381 }
3382
3383
3384 DWORD
3385 STDCALL
3386 SetTapeParameters (
3387         HANDLE  hDevice,
3388         DWORD   dwOperation,
3389         LPVOID  lpTapeInformation
3390         )
3391 {
3392         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3393         return 0;
3394 }
3395
3396
3397 DWORD
3398 STDCALL
3399 SetTapePosition (
3400         HANDLE  hDevice,
3401         DWORD   dwPositionMethod,
3402         DWORD   dwPartition,
3403         DWORD   dwOffsetLow,
3404         DWORD   dwOffsetHigh,
3405         WINBOOL bImmediate
3406         )
3407 {
3408         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3409         return FALSE;
3410 }
3411
3412
3413 WINBOOL
3414 STDCALL
3415 SetThreadLocale (
3416         LCID    Locale
3417         )
3418 {
3419         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3420         return FALSE;
3421 }
3422
3423
3424 WINBOOL
3425 STDCALL
3426 SetVDMCurrentDirectories (
3427         DWORD   Unknown0,
3428         DWORD   Unknown1
3429         )
3430 {
3431         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3432         return FALSE;
3433 }
3434
3435
3436 WINBOOL
3437 STDCALL
3438 SetupComm (
3439         HANDLE  hFile,
3440         DWORD   dwInQueue,
3441         DWORD   dwOutQueue
3442         )
3443 {
3444         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3445         return FALSE;
3446 }
3447
3448
3449 DWORD
3450 STDCALL
3451 ShowConsoleCursor (
3452         DWORD   Unknown0,
3453         DWORD   Unknown1
3454         )
3455 {
3456         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3457         return 0;
3458 }
3459
3460
3461
3462
3463
3464
3465
3466
3467
3468 WINBOOL
3469 STDCALL
3470 TransactNamedPipe (
3471         HANDLE          hNamedPipe,
3472         LPVOID          lpInBuffer,
3473         DWORD           nInBufferSize,
3474         LPVOID          lpOutBuffer,
3475         DWORD           nOutBufferSize,
3476         LPDWORD         lpBytesRead,
3477         LPOVERLAPPED    lpOverlapped
3478         )
3479 {
3480         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3481         return FALSE;
3482 }
3483
3484
3485 WINBOOL
3486 STDCALL
3487 TransmitCommChar (
3488         HANDLE  hFile,
3489         char    cChar
3490         )
3491 {
3492         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3493         return FALSE;
3494 }
3495
3496
3497 DWORD
3498 STDCALL
3499 TrimVirtualBuffer (
3500         DWORD   Unknown0
3501         )
3502 {
3503         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3504         return 0;
3505 }
3506
3507
3508 WINBOOL
3509 STDCALL
3510 UpdateResourceA (
3511         HANDLE  hUpdate,
3512         LPCSTR  lpType,
3513         LPCSTR  lpName,
3514         WORD    wLanguage,
3515         LPVOID  lpData,
3516         DWORD   cbData
3517         )
3518 {
3519         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3520         return FALSE;
3521 }
3522
3523
3524 WINBOOL
3525 STDCALL
3526 UpdateResourceW (
3527         HANDLE  hUpdate,
3528         LPCWSTR lpType,
3529         LPCWSTR lpName,
3530         WORD    wLanguage,
3531         LPVOID  lpData,
3532         DWORD   cbData
3533         )
3534 {
3535         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3536         return FALSE;
3537 }
3538
3539
3540 DWORD
3541 STDCALL
3542 VDMConsoleOperation (
3543         DWORD   Unknown0,
3544         DWORD   Unknown1
3545         )
3546 {
3547         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3548         return 0;
3549 }
3550
3551
3552 DWORD
3553 STDCALL
3554 VDMOperationStarted (
3555         DWORD   Unknown0
3556         )
3557 {
3558         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3559         return 0;
3560 }
3561
3562
3563 DWORD
3564 STDCALL
3565 VerLanguageNameA (
3566         DWORD   wLang,
3567         LPSTR   szLang,
3568         DWORD   nSize
3569         )
3570 {
3571         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3572         return 0;
3573 }
3574
3575
3576 DWORD
3577 STDCALL
3578 VerLanguageNameW (
3579         DWORD   wLang,
3580         LPWSTR  szLang,
3581         DWORD   nSize
3582         )
3583 {
3584         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3585         return 0;
3586 }
3587
3588
3589 DWORD
3590 STDCALL
3591 VerifyConsoleIoHandle (
3592         DWORD   Unknown0
3593         )
3594 {
3595         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3596         return 0;
3597 }
3598
3599
3600 DWORD
3601 STDCALL
3602 VirtualBufferExceptionHandler (
3603         DWORD   Unknown0,
3604         DWORD   Unknown1,
3605         DWORD   Unknown2
3606         )
3607 {
3608         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3609         return 0;
3610 }
3611
3612
3613 WINBOOL
3614 STDCALL
3615 WaitCommEvent (
3616         HANDLE          hFile,
3617         LPDWORD         lpEvtMask,
3618         LPOVERLAPPED    lpOverlapped
3619         )
3620 {
3621         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3622         return FALSE;
3623 }
3624
3625
3626 int
3627 STDCALL
3628 WideCharToMultiByte (
3629         UINT    CodePage,
3630         DWORD   dwFlags,
3631         LPCWSTR lpWideCharStr,
3632         int     cchWideChar,
3633         LPSTR   lpMultiByteStr,
3634         int     cchMultiByte,
3635         LPCSTR  lpDefaultChar,
3636         LPBOOL  lpUsedDefaultChar
3637         )
3638 {
3639         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3640         return FALSE;
3641 }
3642
3643
3644 DWORD
3645 STDCALL
3646 WriteConsoleInputVDMA (
3647         DWORD   Unknown0,
3648         DWORD   Unknown1,
3649         DWORD   Unknown2,
3650         DWORD   Unknown3
3651         )
3652 {
3653         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3654         return 0;
3655 }
3656
3657
3658 DWORD
3659 STDCALL
3660 WriteConsoleInputVDMW (
3661         DWORD   Unknown0,
3662         DWORD   Unknown1,
3663         DWORD   Unknown2,
3664         DWORD   Unknown3
3665         )
3666 {
3667         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3668         return 0;
3669 }
3670
3671
3672 WINBOOL
3673 STDCALL
3674 WritePrivateProfileSectionA (
3675         LPCSTR  lpAppName,
3676         LPCSTR  lpString,
3677         LPCSTR  lpFileName
3678         )
3679 {
3680         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3681         return FALSE;
3682 }
3683
3684
3685 WINBOOL
3686 STDCALL
3687 WritePrivateProfileSectionW (
3688         LPCWSTR lpAppName,
3689         LPCWSTR lpString,
3690         LPCWSTR lpFileName
3691         )
3692 {
3693         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3694         return FALSE;
3695 }
3696
3697
3698 WINBOOL
3699 STDCALL
3700 WritePrivateProfileStringA (
3701         LPCSTR  lpAppName,
3702         LPCSTR  lpKeyName,
3703         LPCSTR  lpString,
3704         LPCSTR  lpFileName
3705         )
3706 {
3707         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3708         return FALSE;
3709 }
3710
3711
3712 WINBOOL
3713 STDCALL
3714 WritePrivateProfileStringW (
3715         LPCWSTR lpAppName,
3716         LPCWSTR lpKeyName,
3717         LPCWSTR lpString,
3718         LPCWSTR lpFileName
3719         )
3720 {
3721         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3722         return FALSE;
3723 }
3724
3725
3726 WINBOOL
3727 STDCALL
3728 WritePrivateProfileStructA (
3729         DWORD   Unknown0,
3730         DWORD   Unknown1,
3731         DWORD   Unknown2,
3732         DWORD   Unknown3,
3733         DWORD   Unknown4
3734         )
3735 {
3736         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3737         return FALSE;
3738 }
3739
3740
3741 WINBOOL
3742 STDCALL
3743 WritePrivateProfileStructW (
3744         DWORD   Unknown0,
3745         DWORD   Unknown1,
3746         DWORD   Unknown2,
3747         DWORD   Unknown3,
3748         DWORD   Unknown4
3749         )
3750 {
3751         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3752         return FALSE;
3753 }
3754
3755
3756
3757
3758 WINBOOL
3759 STDCALL
3760 WriteProfileSectionA (
3761         LPCSTR  lpAppName,
3762         LPCSTR  lpString
3763         )
3764 {
3765         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3766         return FALSE;
3767 }
3768
3769
3770 WINBOOL
3771 STDCALL
3772 WriteProfileSectionW (
3773         LPCWSTR lpAppName,
3774         LPCWSTR lpString
3775         )
3776 {
3777         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3778         return FALSE;
3779 }
3780
3781
3782 WINBOOL
3783 STDCALL
3784 WriteProfileStringA (
3785         LPCSTR  lpAppName,
3786         LPCSTR  lpKeyName,
3787         LPCSTR  lpString
3788         )
3789 {
3790         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3791         return FALSE;
3792 }
3793
3794
3795 WINBOOL
3796 STDCALL
3797 WriteProfileStringW (
3798         LPCWSTR lpAppName,
3799         LPCWSTR lpKeyName,
3800         LPCWSTR lpString
3801         )
3802 {
3803         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3804         return FALSE;
3805 }
3806
3807
3808 DWORD
3809 STDCALL
3810 WriteTapemark (
3811         HANDLE  hDevice,
3812         DWORD   dwTapemarkType,
3813         DWORD   dwTapemarkCount,
3814         WINBOOL bImmediate
3815         )
3816 {
3817         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3818         return 0;
3819 }
3820
3821 DWORD
3822 STDCALL
3823 GetTapePosition (
3824         HANDLE  hDevice,
3825         DWORD   dwPositionType,
3826         LPDWORD lpdwPartition,
3827         LPDWORD lpdwOffsetLow,
3828         LPDWORD lpdwOffsetHigh
3829         )
3830 {
3831         SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
3832         return 0;
3833 }
3834
3835
3836
3837 /* EOF */