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