source: trunk/src/crtdll/crt.cpp@ 2177

Last change on this file since 2177 was 2177, checked in by sandervl, 26 years ago

all crt functions moved to crtdll
File size: 45.6 KB
Line 
1/* $Id: crt.cpp,v 1.1 1999-12-21 12:27:11 sandervl Exp $ */
2
3/*
4 * Project Odin Software License can be found in LICENSE.TXT
5 * Win32 NT Runtime / NTDLL for OS/2
6 * Copyright 1999 Patrick Haller (phaller@gmx.net)
7 */
8
9/****************************************************************************
10 * Include *
11 ****************************************************************************/
12
13#include <odin.h>
14#include <stdlib.h>
15#include <stdio.h>
16#include <string.h>
17#include <math.h>
18#include <ctype.h>
19#include <wchar.h>
20#include <wcstr.h>
21#include <wctype.h>
22
23#include <os2win.h>
24#include <misc.h>
25
26#include <ntdef.h>
27#include <winnt.h>
28#include "winbase.h" /* fixme: should be taken out sometimes */
29#include <heapstring.h>
30#include "asmhlp.h"
31
32
33/****************************************************************************
34 * Local Prototypes *
35 ****************************************************************************/
36
37
38LPWSTR CDECL CRTDLL__wcsupr(LPWSTR str);
39int CDECL CRTDLL__wcsnicmp(LPWSTR str1, LPWSTR str2, long l);
40
41
42
43/*****************************************************************************
44 * Name :
45 * Purpose :
46 * Parameters:
47 * Variables :
48 * Result :
49 * Remark : NTDLL.879
50 * Status :
51 *
52 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
53 *****************************************************************************/
54
55int CDECL CRTDLL__wcsicmp(LPWSTR str1, LPWSTR str2)
56{
57 dprintf(("CRTDLL: _wcsicmp(%08xh,%08xh)\n",
58 str1,
59 str2));
60
61 return (CRTDLL__wcsnicmp(str1,
62 str2,
63 wcslen((wchar_t*) str1)));
64}
65
66
67/*****************************************************************************
68 * Name :
69 * Purpose :
70 * Parameters:
71 * Variables :
72 * Result :
73 * Remark : NTDLL.880
74 * Status :
75 *
76 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
77 *****************************************************************************/
78
79LPWSTR CDECL CRTDLL__wcslwr(LPWSTR str)
80{
81 DWORD dwIndex;
82
83 dprintf(("CRTDLL: _wcslwr(%08xh)\n",
84 str));
85
86 for (dwIndex = wcslen((const wchar_t*)str);
87 dwIndex;
88 dwIndex--)
89 {
90 towlower(str[dwIndex]);
91 }
92
93 return (str);
94}
95
96
97/*****************************************************************************
98 * Name :
99 * Purpose :
100 * Parameters:
101 * Variables :
102 * Result :
103 * Remark : NTDLL.881
104 * Status :
105 *
106 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
107 *****************************************************************************/
108
109int CDECL CRTDLL__wcsnicmp(LPWSTR str1, LPWSTR str2, long l)
110{
111 LPWSTR w1;
112 LPWSTR w2;
113
114 dprintf(("CRTDLL: _wcsnicmp(%08xh,%08xh,%08xh)\n",
115 str1,
116 str2,
117 l));
118
119 w1 = HEAP_strdupW(GetProcessHeap(),0,str1);
120 w2 = HEAP_strdupW(GetProcessHeap(),0,str2);
121 CRTDLL__wcsupr(w1);
122 CRTDLL__wcsupr(w2);
123
124 return (wcsncmp((wchar_t*)w1,
125 (wchar_t*)w2,
126 l));
127}
128
129
130/*****************************************************************************
131 * Name :
132 * Purpose :
133 * Parameters:
134 * Variables :
135 * Result :
136 * Remark : NTDLL.882
137 * Status :
138 *
139 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
140 *****************************************************************************/
141
142LPWSTR CDECL CRTDLL__wcsupr(LPWSTR str)
143{
144 DWORD dwIndex;
145
146 dprintf(("CRTDLL: _wcsupr(%08xh)\n",
147 str));
148
149 for (dwIndex = wcslen((const wchar_t*)str);
150 dwIndex;
151 dwIndex--)
152 {
153 towupper(str[dwIndex]);
154 }
155
156 return (str);
157}
158
159
160
161/*****************************************************************************
162 * Name :
163 * Purpose :
164 * Parameters:
165 * Variables :
166 * Result :
167 * Remark : NTDLL.883
168 * Status :
169 *
170 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
171 *****************************************************************************/
172
173double CDECL CRTDLL_abs(double d)
174{
175 dprintf(("CRTDLL: abs(%f)\n",
176 d));
177
178 return (abs(d));
179}
180
181
182/*****************************************************************************
183 * Name :
184 * Purpose :
185 * Parameters:
186 * Variables :
187 * Result :
188 * Remark : NTDLL.884
189 * Status :
190 *
191 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
192 *****************************************************************************/
193
194double CDECL CRTDLL_atan(double d)
195{
196 dprintf(("CRTDLL: atan(%f)\n",
197 d));
198
199 return (atan(d));
200}
201
202
203/*****************************************************************************
204 * Name :
205 * Purpose :
206 * Parameters:
207 * Variables :
208 * Result :
209 * Remark : NTDLL.885
210 * Status :
211 *
212 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
213 *****************************************************************************/
214
215int CDECL CRTDLL_atoi(LPSTR str)
216{
217 dprintf(("CRTDLL: atoi(%s)\n",
218 str));
219
220 return (atoi(str));
221}
222
223
224/*****************************************************************************
225 * Name :
226 * Purpose :
227 * Parameters:
228 * Variables :
229 * Result :
230 * Remark : NTDLL.886
231 * Status :
232 *
233 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
234 *****************************************************************************/
235
236long CDECL CRTDLL_atol(LPSTR str)
237{
238 dprintf(("CRTDLL: atol(%s)\n",
239 str));
240
241 return (atol(str));
242}
243
244
245/*****************************************************************************
246 * Name :
247 * Purpose :
248 * Parameters:
249 * Variables :
250 * Result :
251 * Remark : NTDLL.887
252 * Status :
253 *
254 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
255 *****************************************************************************/
256
257double CDECL CRTDLL_ceil(double d)
258{
259 dprintf(("CRTDLL: ceil(%f)\n",
260 d));
261
262 return (ceil(d));
263}
264
265
266/*****************************************************************************
267 * Name :
268 * Purpose :
269 * Parameters:
270 * Variables :
271 * Result :
272 * Remark : NTDLL.888
273 * Status :
274 *
275 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
276 *****************************************************************************/
277
278double CDECL CRTDLL_cos(double d)
279{
280 dprintf(("CRTDLL: cos(%f)\n",
281 d));
282
283 return (cos(d));
284}
285
286
287/*****************************************************************************
288 * Name :
289 * Purpose :
290 * Parameters:
291 * Variables :
292 * Result :
293 * Remark : NTDLL.889
294 * Status :
295 *
296 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
297 *****************************************************************************/
298
299double CDECL CRTDLL_fabs(double d)
300{
301 dprintf(("CRTDLL: fabs(%f)\n",
302 d));
303
304 return (fabs(d));
305}
306
307
308/*****************************************************************************
309 * Name :
310 * Purpose :
311 * Parameters:
312 * Variables :
313 * Result :
314 * Remark : NTDLL.890
315 * Status :
316 *
317 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
318 *****************************************************************************/
319
320double CDECL CRTDLL_floor(double d)
321{
322 dprintf(("CRTDLL: floor(%f)\n",
323 d));
324
325 return (floor(d));
326}
327
328
329/*****************************************************************************
330 * Name :
331 * Purpose :
332 * Parameters:
333 * Variables :
334 * Result :
335 * Remark : NTDLL.891
336 * Status :
337 *
338 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
339 *****************************************************************************/
340
341int CDECL CRTDLL_isalpha(int i)
342{
343 dprintf(("CRTDLL: isalpha(%08xh)\n",
344 i));
345
346 return (isalpha(i));
347}
348
349
350/*****************************************************************************
351 * Name :
352 * Purpose :
353 * Parameters:
354 * Variables :
355 * Result :
356 * Remark : NTDLL.892
357 * Status :
358 *
359 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
360 *****************************************************************************/
361
362int CDECL CRTDLL_isdigit(int i)
363{
364 dprintf(("CRTDLL: isdigit(%08xh)\n",
365 i));
366
367 return (isdigit(i));
368}
369
370
371/*****************************************************************************
372 * Name :
373 * Purpose :
374 * Parameters:
375 * Variables :
376 * Result :
377 * Remark : NTDLL.893
378 * Status :
379 *
380 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
381 *****************************************************************************/
382
383int CDECL CRTDLL_islower(int i)
384{
385 dprintf(("CRTDLL: islower(%08xh)\n",
386 i));
387
388 return (islower(i));
389}
390
391
392/*****************************************************************************
393 * Name :
394 * Purpose :
395 * Parameters:
396 * Variables :
397 * Result :
398 * Remark : NTDLL.894
399 * Status :
400 *
401 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
402 *****************************************************************************/
403
404int CDECL CRTDLL_isprint(int i)
405{
406 dprintf(("CRTDLL: isprint(%08xh)\n",
407 i));
408
409 return (isprint(i));
410}
411
412
413/*****************************************************************************
414 * Name :
415 * Purpose :
416 * Parameters:
417 * Variables :
418 * Result :
419 * Remark : NTDLL.895
420 * Status :
421 *
422 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
423 *****************************************************************************/
424
425int CDECL CRTDLL_isspace(int i)
426{
427 dprintf(("CRTDLL: isspace(%08xh)\n",
428 i));
429
430 return (isspace(i));
431}
432
433
434/*****************************************************************************
435 * Name :
436 * Purpose :
437 * Parameters:
438 * Variables :
439 * Result :
440 * Remark : NTDLL.896
441 * Status :
442 *
443 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
444 *****************************************************************************/
445
446int CDECL CRTDLL_isupper(int i)
447{
448 dprintf(("CRTDLL: isupper(%08xh)\n",
449 i));
450
451 return (isupper(i));
452}
453
454
455/*****************************************************************************
456 * Name :
457 * Purpose :
458 * Parameters:
459 * Variables :
460 * Result :
461 * Remark : NTDLL.911
462 * Status :
463 *
464 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
465 *****************************************************************************/
466
467LPSTR CDECL CRTDLL_sprintf(LPSTR lpstrBuffer,
468 LPSTR lpstrFormat,
469 ...)
470{
471 va_list argptr; /* -> variable argument list */
472
473 dprintf(("CRTDLL: sprintf(%08xh,%s)\n",
474 lpstrBuffer,
475 lpstrFormat));
476
477 va_start(argptr,
478 lpstrFormat); /* get pointer to argument list */
479 vsprintf(lpstrBuffer,
480 lpstrFormat,
481 argptr);
482 va_end(argptr); /* done with variable arguments */
483
484 return (lpstrBuffer);
485}
486
487
488
489/*****************************************************************************
490 * Name :
491 * Purpose :
492 * Parameters:
493 * Variables :
494 * Result :
495 * Remark : NTDLL.914
496 * Status :
497 *
498 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
499 *****************************************************************************/
500
501LPSTR CDECL CRTDLL_strcat( LPSTR str1,
502 const LPSTR str2)
503{
504 dprintf(("CRTDLL: strcat\n"));
505
506 return (strcat(str1, str2));
507}
508
509
510/*****************************************************************************
511 * Name :
512 * Purpose :
513 * Parameters:
514 * Variables :
515 * Result :
516 * Remark : NTDLL.915
517 * Status :
518 *
519 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
520 *****************************************************************************/
521
522LPSTR CDECL CRTDLL_strchr(const LPSTR str,
523 int i)
524{
525 dprintf(("CRTDLL: strchr(%s,%08xh)\n",
526 str,
527 i));
528
529 return (strchr(str, i));
530}
531
532
533/*****************************************************************************
534 * Name :
535 * Purpose :
536 * Parameters:
537 * Variables :
538 * Result :
539 * Remark : NTDLL.916
540 * Status :
541 *
542 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
543 *****************************************************************************/
544
545int CDECL CRTDLL_strcmp(const LPSTR str1,
546 const LPSTR str2)
547{
548 dprintf(("CRTDLL: strcmp(%s,%s)\n",
549 str1,
550 str2));
551
552 return (strcmp(str1, str2));
553}
554
555
556/*****************************************************************************
557 * Name :
558 * Purpose :
559 * Parameters:
560 * Variables :
561 * Result :
562 * Remark : NTDLL.?
563 * Status :
564 *
565 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
566 *****************************************************************************/
567
568int CDECL CRTDLL__stricmp(const LPSTR str1,
569 const LPSTR str2)
570{
571 dprintf(("CRTDLL: _stricmp(%s,%s)\n",
572 str1,
573 str2));
574
575 return (stricmp(str1, str2));
576}
577
578
579/*****************************************************************************
580 * Name :
581 * Purpose :
582 * Parameters:
583 * Variables :
584 * Result :
585 * Remark : NTDLL.917
586 * Status :
587 *
588 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
589 *****************************************************************************/
590
591LPSTR CDECL CRTDLL_strcpy( LPSTR str1,
592 const LPSTR str2)
593{
594 dprintf(("CRTDLL: strcpy\n"));
595
596 return (strcpy(str1, str2));
597}
598
599
600/*****************************************************************************
601 * Name :
602 * Purpose :
603 * Parameters:
604 * Variables :
605 * Result :
606 * Remark : NTDLL.918
607 * Status :
608 *
609 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
610 *****************************************************************************/
611
612size_t CDECL CRTDLL_strcspn(const LPSTR str1,
613 LPSTR str2)
614{
615 dprintf(("CRTDLL: strcspn(%s,%s)\n",
616 str1,
617 str2));
618
619 return (strcspn(str1, str2));
620}
621
622
623/*****************************************************************************
624 * Name :
625 * Purpose :
626 * Parameters:
627 * Variables :
628 * Result :
629 * Remark : NTDLL.919
630 * Status :
631 *
632 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
633 *****************************************************************************/
634
635size_t CDECL CRTDLL_strlen(const LPSTR str)
636{
637 dprintf(("CRTDLL: strlen(%s)\n",
638 str));
639
640 return (strlen(str));
641}
642
643
644/*****************************************************************************
645 * Name :
646 * Purpose :
647 * Parameters:
648 * Variables :
649 * Result :
650 * Remark : NTDLL.920
651 * Status :
652 *
653 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
654 *****************************************************************************/
655
656LPSTR CDECL CRTDLL_strncat( LPSTR str1,
657 const LPSTR str2,
658 size_t i)
659{
660 dprintf(("CRTDLL: strncat(%s,%s,%08xh)\n",
661 str1,
662 str2,
663 i));
664
665 return (strncat(str1, str2, i));
666}
667
668
669/*****************************************************************************
670 * Name :
671 * Purpose :
672 * Parameters:
673 * Variables :
674 * Result :
675 * Remark : NTDLL.921
676 * Status :
677 *
678 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
679 *****************************************************************************/
680
681int CDECL CRTDLL_strncmp(const LPSTR str1,
682 const LPSTR str2,
683 size_t i)
684{
685 dprintf(("CRTDLL: strncmp(%s,%s,%08xh)\n",
686 str1,
687 str2,
688 i));
689
690 return (strncmp(str1, str2, i));
691}
692
693
694/*****************************************************************************
695 * Name :
696 * Purpose :
697 * Parameters:
698 * Variables :
699 * Result :
700 * Remark : NTDLL.922
701 * Status :
702 *
703 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
704 *****************************************************************************/
705
706LPSTR CDECL CRTDLL_strncpy(const LPSTR str1,
707 const LPSTR str2,
708 size_t i)
709{
710 dprintf(("CRTDLL: strncpy(%s,%s,%08xh)\n",
711 str1,
712 str2,
713 i));
714
715 return (strncpy(str1, str2, i));
716}
717
718
719/*****************************************************************************
720 * Name :
721 * Purpose :
722 * Parameters:
723 * Variables :
724 * Result :
725 * Remark : NTDLL.923
726 * Status :
727 *
728 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
729 *****************************************************************************/
730
731LPSTR CDECL CRTDLL_strpbrk(const LPSTR str1,
732 const LPSTR str2)
733{
734 dprintf(("CRTDLL: strpbrk(%s,%s)\n",
735 str1,
736 str2));
737
738 return (strpbrk(str1, str2));
739}
740
741
742/*****************************************************************************
743 * Name :
744 * Purpose :
745 * Parameters:
746 * Variables :
747 * Result :
748 * Remark : NTDLL.924
749 * Status :
750 *
751 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
752 *****************************************************************************/
753
754LPSTR CDECL CRTDLL_strrchr(const LPSTR str,
755 size_t i)
756{
757 dprintf(("CRTDLL: strrchr(%s,%08xh)\n",
758 str,
759 i));
760
761 return (strrchr(str, i));
762}
763
764
765/*****************************************************************************
766 * Name :
767 * Purpose :
768 * Parameters:
769 * Variables :
770 * Result :
771 * Remark : NTDLL.925
772 * Status :
773 *
774 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
775 *****************************************************************************/
776
777size_t CDECL CRTDLL_strspn(const LPSTR str1,
778 const LPSTR str2)
779{
780 dprintf(("CRTDLL: strspn(%s,%s)\n",
781 str1,
782 str2));
783
784 return (strspn(str1, str2));
785}
786
787
788/*****************************************************************************
789 * Name :
790 * Purpose :
791 * Parameters:
792 * Variables :
793 * Result :
794 * Remark : NTDLL.926
795 * Status :
796 *
797 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
798 *****************************************************************************/
799
800LPSTR CDECL CRTDLL_strstr(const LPSTR str1,
801 const LPSTR str2)
802{
803 dprintf(("CRTDLL: strstr(%s,%s)\n",
804 str1,
805 str2));
806
807 return (strstr(str1, str2));
808}
809
810
811/*****************************************************************************
812 * Name :
813 * Purpose :
814 * Parameters:
815 * Variables :
816 * Result :
817 * Remark : NTDLL.927
818 * Status :
819 *
820 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
821 *****************************************************************************/
822
823int CDECL CRTDLL_swprintf(const LPWSTR str,
824 int i,
825 const LPWSTR format,
826 ...)
827{
828 va_list valist;
829 int rc;
830
831 dprintf(("CRTDLL: swprintf(%s,%d,%s)\n",
832 str,
833 i,
834 format));
835
836 va_start( valist, format );
837 rc = vswprintf( (wchar_t*)str,
838 i,
839 (wchar_t*)format,
840 valist );
841 va_end( valist );
842 return rc;
843}
844
845
846/*****************************************************************************
847 * Name :
848 * Purpose :
849 * Parameters:
850 * Variables :
851 * Result :
852 * Remark : NTDLL.928
853 * Status :
854 *
855 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
856 *****************************************************************************/
857
858double CDECL CRTDLL_tan(double d)
859{
860 dprintf(("CRTDLL: tan(%f)\n",
861 d));
862
863 return (tan(d));
864}
865
866
867/*****************************************************************************
868 * Name :
869 * Purpose :
870 * Parameters:
871 * Variables :
872 * Result :
873 * Remark : NTDLL.929
874 * Status :
875 *
876 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
877 *****************************************************************************/
878
879int CDECL CRTDLL_toupper(int c)
880{
881 dprintf(("CRTDLL: toupper(%c)\n",
882 c));
883
884 return (toupper(c));
885}
886
887
888/*****************************************************************************
889 * Name :
890 * Purpose :
891 * Parameters:
892 * Variables :
893 * Result :
894 * Remark : NTDLL.930
895 * Status :
896 *
897 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
898 *****************************************************************************/
899
900int CDECL CRTDLL_tolower(int c)
901{
902 dprintf(("CRTDLL: tolower(%c)\n",
903 c));
904
905 return (tolower(c));
906}
907
908
909/*****************************************************************************
910 * Name :
911 * Purpose :
912 * Parameters:
913 * Variables :
914 * Result :
915 * Remark : NTDLL.931
916 * Status :
917 *
918 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
919 *****************************************************************************/
920
921int CDECL CRTDLL_towupper(int c)
922{
923 dprintf(("CRTDLL: towupper(%c)\n",
924 c));
925
926 return (towupper(c));
927}
928
929
930/*****************************************************************************
931 * Name :
932 * Purpose :
933 * Parameters:
934 * Variables :
935 * Result :
936 * Remark : NTDLL.932
937 * Status :
938 *
939 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
940 *****************************************************************************/
941
942int CDECL CRTDLL_towlower(int c)
943{
944 dprintf(("CRTDLL: towlower(%c)\n",
945 c));
946
947 return (towlower(c));
948}
949
950
951
952/*****************************************************************************
953 * Name :
954 * Purpose :
955 * Parameters:
956 * Variables :
957 * Result :
958 * Remark : NTDLL.934
959 * Status :
960 *
961 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
962 *****************************************************************************/
963
964wchar_t* CDECL CRTDLL_wcscat( wchar_t* str1,
965 const wchar_t* str2)
966{
967 dprintf(("CRTDLL: wcscat(%08xh,%08xh)\n",
968 str1,
969 str2));
970
971 return (wcscat(str1, str2));
972}
973
974
975/*****************************************************************************
976 * Name :
977 * Purpose :
978 * Parameters:
979 * Variables :
980 * Result :
981 * Remark : NTDLL.935
982 * Status :
983 *
984 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
985 *****************************************************************************/
986
987wchar_t* CDECL CRTDLL_wcschr(const wchar_t* str,
988 int i)
989{
990 dprintf(("CRTDLL: wcschr(%08xh,%08xh)\n",
991 str,
992 i));
993
994 return (wcschr(str, i));
995}
996
997
998/*****************************************************************************
999 * Name :
1000 * Purpose :
1001 * Parameters:
1002 * Variables :
1003 * Result :
1004 * Remark : NTDLL.936
1005 * Status :
1006 *
1007 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1008 *****************************************************************************/
1009
1010int CDECL CRTDLL_wcscmp(const wchar_t* str1,
1011 const wchar_t* str2)
1012{
1013 dprintf(("CRTDLL: wcscmp(%08xh,%08xh)\n",
1014 str1,
1015 str2));
1016
1017 return (wcscmp(str1, str2));
1018}
1019
1020
1021/*****************************************************************************
1022 * Name :
1023 * Purpose :
1024 * Parameters:
1025 * Variables :
1026 * Result :
1027 * Remark : NTDLL.937
1028 * Status :
1029 *
1030 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1031 *****************************************************************************/
1032
1033wchar_t* CDECL CRTDLL_wcscpy( wchar_t* str1,
1034 const wchar_t* str2)
1035{
1036 dprintf(("CRTDLL: wcscpy(%08xh,%08xh)\n",
1037 str1,
1038 str2));
1039
1040 return (wcscpy(str1, str2));
1041}
1042
1043
1044/*****************************************************************************
1045 * Name :
1046 * Purpose :
1047 * Parameters:
1048 * Variables :
1049 * Result :
1050 * Remark : NTDLL.938
1051 * Status :
1052 *
1053 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1054 *****************************************************************************/
1055
1056size_t CDECL CRTDLL_wcscspn(const wchar_t* str1,
1057 wchar_t* str2)
1058{
1059 dprintf(("CRTDLL: wcscspn(%08xh,%08xh)\n",
1060 str1,
1061 str2));
1062
1063 return (wcscspn(str1, str2));
1064}
1065
1066
1067/*****************************************************************************
1068 * Name :
1069 * Purpose :
1070 * Parameters:
1071 * Variables :
1072 * Result :
1073 * Remark : NTDLL.939
1074 * Status :
1075 *
1076 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1077 *****************************************************************************/
1078
1079size_t CDECL CRTDLL_wcslen(const wchar_t* str)
1080{
1081 dprintf(("CRTDLL: wcslen(%08xh)\n",
1082 str));
1083
1084 return (wcslen(str));
1085}
1086
1087
1088/*****************************************************************************
1089 * Name :
1090 * Purpose :
1091 * Parameters:
1092 * Variables :
1093 * Result :
1094 * Remark : NTDLL.940
1095 * Status :
1096 *
1097 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1098 *****************************************************************************/
1099
1100wchar_t* CDECL CRTDLL_wcsncat( wchar_t* str1,
1101 const wchar_t* str2,
1102 size_t i)
1103{
1104 dprintf(("CRTDLL: wcsncat(%08xh,%08xh,%08xh)\n",
1105 str1,
1106 str2,
1107 i));
1108
1109 return (wcsncat(str1, str2, i));
1110}
1111
1112
1113/*****************************************************************************
1114 * Name :
1115 * Purpose :
1116 * Parameters:
1117 * Variables :
1118 * Result :
1119 * Remark : NTDLL.941
1120 * Status :
1121 *
1122 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1123 *****************************************************************************/
1124
1125int CDECL CRTDLL_wcsncmp(const wchar_t* str1,
1126 const wchar_t* str2,
1127 size_t i)
1128{
1129 dprintf(("CRTDLL: wcsncmp(%08xh,%08xh,%08xh)\n",
1130 str1,
1131 str2,
1132 i));
1133
1134 return (wcsncmp(str1, str2, i));
1135}
1136
1137
1138/*****************************************************************************
1139 * Name :
1140 * Purpose :
1141 * Parameters:
1142 * Variables :
1143 * Result :
1144 * Remark : NTDLL.942
1145 * Status :
1146 *
1147 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1148 *****************************************************************************/
1149
1150wchar_t* CDECL CRTDLL_wcsncpy( wchar_t* str1,
1151 const wchar_t* str2,
1152 size_t i)
1153{
1154 dprintf(("CRTDLL: wcsncpy(%s,%s,%08xh)\n",
1155 str1,
1156 str2,
1157 i));
1158
1159 return (wcsncpy(str1, str2, i));
1160}
1161
1162
1163/*****************************************************************************
1164 * Name :
1165 * Purpose :
1166 * Parameters:
1167 * Variables :
1168 * Result :
1169 * Remark : NTDLL.943
1170 * Status :
1171 *
1172 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1173 *****************************************************************************/
1174
1175wchar_t* CDECL CRTDLL_wcspbrk(const wchar_t* str1,
1176 const wchar_t* str2)
1177{
1178 dprintf(("CRTDLL: wcspbrk(%08xh,%08xh)\n",
1179 str1,
1180 str2));
1181
1182 return (wcspbrk(str1, str2));
1183}
1184
1185
1186/*****************************************************************************
1187 * Name :
1188 * Purpose :
1189 * Parameters:
1190 * Variables :
1191 * Result :
1192 * Remark : NTDLL.944
1193 * Status :
1194 *
1195 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1196 *****************************************************************************/
1197
1198wchar_t* CDECL CRTDLL_wcsrchr(const wchar_t* str,
1199 size_t i)
1200{
1201 dprintf(("CRTDLL: wcsrchr(%08xh,%08xh)\n",
1202 str,
1203 i));
1204
1205 return (wcsrchr(str, i));
1206}
1207
1208
1209/*****************************************************************************
1210 * Name :
1211 * Purpose :
1212 * Parameters:
1213 * Variables :
1214 * Result :
1215 * Remark : NTDLL.945
1216 * Status :
1217 *
1218 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1219 *****************************************************************************/
1220
1221size_t CDECL CRTDLL_wcsspn(const wchar_t* str1,
1222 const wchar_t* str2)
1223{
1224 dprintf(("CRTDLL: wcsspn(%08xh,%08xh)\n",
1225 str1,
1226 str2));
1227
1228 return (wcsspn(str1, str2));
1229}
1230
1231
1232/*****************************************************************************
1233 * Name :
1234 * Purpose :
1235 * Parameters:
1236 * Variables :
1237 * Result :
1238 * Remark : NTDLL.946
1239 * Status :
1240 *
1241 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1242 *****************************************************************************/
1243
1244wchar_t* CDECL CRTDLL_wcsstr(const wchar_t* str1,
1245 const wchar_t* str2)
1246{
1247 dprintf(("CRTDLL: wcsstr(%s,%s)\n",
1248 str1,
1249 str2));
1250
1251 return (wcsstr(str1, str2));
1252}
1253
1254
1255/*****************************************************************************
1256 * Name :
1257 * Purpose :
1258 * Parameters:
1259 * Variables :
1260 * Result :
1261 * Remark : NTDLL.?
1262 * Status :
1263 *
1264 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1265 *****************************************************************************/
1266
1267char * CDECL CRTDLL__itoa(int i, char *s, int r)
1268{
1269 dprintf(("CRTDLL: _itoa(%08xh, %08xh, %08xh)\n",
1270 i,
1271 s,
1272 r));
1273
1274 return (itoa(i,s,r));
1275}
1276
1277
1278/*****************************************************************************
1279 * Name :
1280 * Purpose :
1281 * Parameters:
1282 * Variables :
1283 * Result :
1284 * Remark : NTDLL.?
1285 * Status :
1286 *
1287 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1288 *****************************************************************************/
1289
1290char * CDECL CRTDLL__itow(int i, char *s, int r)
1291{
1292 dprintf(("CRTDLL: _itow(%08xh, %08xh, %08xh) no unicode support !\n",
1293 i,
1294 s,
1295 r));
1296
1297 return (itoa(i,s,r));
1298}
1299
1300
1301/*****************************************************************************
1302 * Name :
1303 * Purpose :
1304 * Parameters:
1305 * Variables :
1306 * Result :
1307 * Remark : NTDLL.749
1308 * Status :
1309 *
1310 * Author : Jens Wiessner
1311 *****************************************************************************/
1312
1313LONG CDECL CRTDLL__CIpow()
1314{
1315 double x,y;
1316 POP_FPU(y);
1317 POP_FPU(x);
1318 return pow(x,y);
1319}
1320
1321
1322/*****************************************************************************
1323 * Name :
1324 * Purpose :
1325 * Parameters:
1326 * Variables :
1327 * Result :
1328 * Remark : NTDLL.864
1329 * Status :
1330 *
1331 * Author : Jens Wiessner
1332 *****************************************************************************/
1333
1334LONG CDECL CRTDLL__ftol(void)
1335{
1336 /* don't just do DO_FPU("fistp",retval), because the rounding
1337 * mode must also be set to "round towards zero"... */
1338 double fl;
1339 POP_FPU(fl);
1340 return (LONG)fl;
1341}
1342
1343
1344/*****************************************************************************
1345 * Name :
1346 * Purpose :
1347 * Parameters:
1348 * Variables :
1349 * Result :
1350 * Remark : NTDLL.866
1351 * Status :
1352 *
1353 * Author : Jens Wiessner
1354 *****************************************************************************/
1355
1356LPSTR CDECL CRTDLL__ltoa(long x,LPSTR buf,INT radix)
1357{
1358 return ltoa(x,buf,radix);
1359}
1360
1361
1362/*****************************************************************************
1363 * Name :
1364 * Purpose :
1365 * Parameters:
1366 * Variables :
1367 * Result :
1368 * Remark : NTDLL.868
1369 * Status :
1370 *
1371 * Author : Jens Wiessner
1372 *****************************************************************************/
1373
1374INT CDECL CRTDLL__memicmp(
1375 LPCSTR s1, /* [in] first string */
1376 LPCSTR s2, /* [in] second string */
1377 DWORD len /* [in] length to compare */ )
1378{
1379 dprintf(("CRTDLL: memicmp(%08xh, %08xh, %08xh)\n",s1,s2,len));
1380 int i;
1381
1382 for (i=0;i<len;i++) {
1383 if (tolower(s1[i])<tolower(s2[i]))
1384 return -1;
1385 if (tolower(s1[i])>tolower(s2[i]))
1386 return 1;
1387 }
1388 return 0;
1389}
1390
1391
1392/*****************************************************************************
1393 * Name :
1394 * Purpose :
1395 * Parameters:
1396 * Variables :
1397 * Result :
1398 * Remark : NTDLL.869
1399 * Status :
1400 *
1401 * Author : Jens Wiessner
1402 *****************************************************************************/
1403
1404int CDECL CRTDLL__snprintf( char *buf, size_t bufsize, const char *fmt, ... )
1405{
1406 dprintf(("CRTDLL: _snprintf(%08xh, %08xh, %08xh) not implemented\n",
1407 buf,
1408 bufsize,
1409 fmt));
1410
1411 return 0;
1412}
1413
1414
1415/*****************************************************************************
1416 * Name :
1417 * Purpose :
1418 * Parameters:
1419 * Variables :
1420 * Result :
1421 * Remark : NTDLL.870
1422 * Status :
1423 *
1424 * Author : Jens Wiessner
1425 *****************************************************************************/
1426
1427int CDECL CRTDLL__snwprintf( wchar_t *buf, size_t bufsize, const wchar_t *fmt, ... )
1428{
1429 dprintf(("CRTDLL: _snwprintf(%08xh, %08xh, %08xh) not implemented\n",
1430 buf,
1431 bufsize,
1432 fmt));
1433
1434 return 0;
1435}
1436
1437
1438/*****************************************************************************
1439 * Name :
1440 * Purpose :
1441 * Parameters:
1442 * Variables :
1443 * Result :
1444 * Remark : NTDLL.871
1445 * Status :
1446 *
1447 * Author : Jens Wiessner
1448 *****************************************************************************/
1449
1450void CDECL CRTDLL__splitpath( const char *path, char *drive, char *dir, char *fname, char *ext )
1451{
1452 dprintf(("CRTDLL: _splitpath"));
1453
1454 char *tmp_drive;
1455 char *tmp_dir;
1456 char *tmp_ext;
1457
1458 tmp_drive = (char *)strchr(path,':');
1459 if ( tmp_drive != (char *)NULL ) {
1460 strncpy(drive,tmp_drive-1,1);
1461 *(drive+1) = 0;
1462 }
1463 else {
1464 *drive = 0;
1465 tmp_drive = (char *)path;
1466 }
1467
1468 tmp_dir = (char *)strrchr(path,'\\');
1469 if( tmp_dir != NULL && tmp_dir != tmp_drive + 1 ) {
1470 strncpy(dir,tmp_drive+1,tmp_dir - tmp_drive);
1471 *(dir + (tmp_dir - tmp_drive)) = 0;
1472 }
1473 else
1474 *dir =0;
1475
1476 tmp_ext = ( char *)strrchr(path,'.');
1477 if ( tmp_ext != NULL ) {
1478 strcpy(ext,tmp_ext);
1479 }
1480 else
1481 *ext = 0;
1482 if ( tmp_dir != NULL ) {
1483 strncpy(fname,tmp_dir+1,tmp_ext - tmp_dir - 1);
1484 *(fname + (tmp_ext - tmp_dir -1)) = 0;
1485 }
1486 else
1487 strncpy(fname,path,tmp_ext - path);
1488
1489}
1490
1491
1492/*****************************************************************************
1493 * Name :
1494 * Purpose :
1495 * Parameters:
1496 * Variables :
1497 * Result :
1498 * Remark : NTDLL.872
1499 * Status :
1500 *
1501 * Author : Jens Wiessner
1502 *****************************************************************************/
1503
1504void CDECL CRTDLL__strcmpi( LPCSTR s1, LPCSTR s2 )
1505{
1506 dprintf(("CRTDLL: _strcmpi(%08xh, %08xh)\n",
1507 s1,
1508 s2));
1509
1510 lstrcmpiA( s1, s2 );
1511}
1512
1513
1514/*****************************************************************************
1515 * Name :
1516 * Purpose :
1517 * Parameters:
1518 * Variables :
1519 * Result :
1520 * Remark : NTDLL.874
1521 * Status :
1522 *
1523 * Author : Jens Wiessner
1524 *****************************************************************************/
1525
1526CHAR * CDECL CRTDLL__strlwr(char *x)
1527{
1528 char *y =x;
1529
1530 dprintf(("CRTDLL: _strlwr got %s\n", x));
1531 while (*y) {
1532 if ((*y > 0x40) && (*y< 0x5b))
1533 *y = *y + 0x20;
1534 y++;
1535 }
1536 dprintf((" returned %s\n", x));
1537
1538 return x;
1539}
1540
1541
1542/*****************************************************************************
1543 * Name :
1544 * Purpose :
1545 * Parameters:
1546 * Variables :
1547 * Result :
1548 * Remark : NTDLL.875
1549 * Status :
1550 *
1551 * Author : Jens Wiessner
1552 *****************************************************************************/
1553
1554int CDECL CRTDLL__strnicmp( LPCSTR s1, LPCSTR s2, INT n )
1555{
1556 dprintf(("CRTDLL: _strnicmp (%s,%s,%d)\n",
1557 s1,
1558 s2,
1559 n));
1560
1561 // @@@PH: sure it's not a UNICODE API?
1562 return (lstrncmpiA(s1,s2,n));
1563
1564/*
1565 if (n == 0)
1566 return 0;
1567 do {
1568 if (toupper(*s1) != toupper(*s2++))
1569 return toupper(*(unsigned const char *)s1) - toupper(*(unsigned const char *)--s2);
1570 if (*s1++ == 0)
1571 break;
1572 } while (--n != 0);
1573 return 0;
1574*/
1575}
1576
1577
1578/*****************************************************************************
1579 * Name :
1580 * Purpose :
1581 * Parameters:
1582 * Variables :
1583 * Result :
1584 * Remark : NTDLL.876
1585 * Status :
1586 *
1587 * Author : Jens Wiessner
1588 *****************************************************************************/
1589
1590LPSTR CDECL CRTDLL__strupr(LPSTR x)
1591{
1592 dprintf(("CRTDLL: _strupr(%s)\n",
1593 x));
1594
1595 LPSTR y=x;
1596
1597 while (*y)
1598 {
1599 *y=toupper(*y);
1600 y++;
1601 }
1602 return x;
1603}
1604
1605
1606/*****************************************************************************
1607 * Name :
1608 * Purpose :
1609 * Parameters:
1610 * Variables :
1611 * Result :
1612 * Remark : NTDLL.877
1613 * Status :
1614 *
1615 * Author : Jens Wiessner
1616 *****************************************************************************/
1617
1618LPSTR CDECL CRTDLL__ultoa(long x,LPSTR buf,INT radix)
1619{
1620 return ultoa(x,buf,radix);
1621}
1622
1623
1624/*****************************************************************************
1625 * Name :
1626 * Purpose :
1627 * Parameters:
1628 * Variables :
1629 * Result :
1630 * Remark : NTDLL.878
1631 * Status :
1632 *
1633 * Author : Jens Wiessner
1634 *****************************************************************************/
1635
1636int CDECL CRTDLL__vsnprintf( char *s, size_t bufsize, const char *format, va_list arg )
1637{
1638 dprintf(("CRTDLL: _vsnprintf(%08xh, %08xh, %08xh)\n",
1639 s,
1640 bufsize,
1641 format));
1642
1643 return wvsnprintfA(s, bufsize, format, arg);
1644}
1645
1646
1647/*****************************************************************************
1648 * Name :
1649 * Purpose :
1650 * Parameters:
1651 * Variables :
1652 * Result :
1653 * Remark : NTDLL.897
1654 * Status :
1655 *
1656 * Author : Jens Wiessner
1657 *****************************************************************************/
1658
1659int CDECL CRTDLL_iswalpha(wint_t i)
1660{
1661 dprintf(("CRTDLL: iswalpha(%08xh)\n", i));
1662
1663 return (iswalpha(i));
1664}
1665
1666
1667/*****************************************************************************
1668 * Name :
1669 * Purpose :
1670 * Parameters:
1671 * Variables :
1672 * Result :
1673 * Remark : NTDLL.898
1674 * Status :
1675 *
1676 * Author : Jens Wiessner
1677 *****************************************************************************/
1678
1679int CDECL CRTDLL_iswctype(wint_t i, wctype_t wct)
1680{
1681 dprintf(("CRTDLL: iswctype(%08xh, %08xh)\n", i, wct));
1682
1683 return (iswctype(i, wct));
1684}
1685
1686
1687/*****************************************************************************
1688 * Name :
1689 * Purpose :
1690 * Parameters:
1691 * Variables :
1692 * Result :
1693 * Remark : NTDLL.899
1694 * Status :
1695 *
1696 * Author : Jens Wiessner
1697 *****************************************************************************/
1698
1699int CDECL CRTDLL_isxdigit(int i)
1700{
1701 dprintf(("CRTDLL: isxdigit(%08xh)\n", i));
1702
1703 return (isxdigit(i));
1704}
1705
1706
1707/*****************************************************************************
1708 * Name :
1709 * Purpose :
1710 * Parameters:
1711 * Variables :
1712 * Result :
1713 * Remark : NTDLL.900
1714 * Status :
1715 *
1716 * Author : Jens Wiessner
1717 *****************************************************************************/
1718
1719long int CDECL CRTDLL_labs( long int j )
1720{
1721 dprintf(("CRTDLL: labs(%08xh)\n", j));
1722
1723 return (labs(j));
1724}
1725
1726
1727/*****************************************************************************
1728 * Name :
1729 * Purpose :
1730 * Parameters:
1731 * Variables :
1732 * Result :
1733 * Remark : NTDLL.901
1734 * Status :
1735 *
1736 * Author : Jens Wiessner
1737 *****************************************************************************/
1738
1739double CDECL CRTDLL_log( double x )
1740{
1741 dprintf(("CRTDLL: log(%08xh)\n", x));
1742 return (log(x));
1743}
1744
1745
1746/*****************************************************************************
1747 * Name :
1748 * Purpose :
1749 * Parameters:
1750 * Variables :
1751 * Result :
1752 * Remark : NTDLL.902
1753 * Status :
1754 *
1755 * Author : Jens Wiessner
1756 *****************************************************************************/
1757
1758size_t CDECL CRTDLL_mbstowcs( wchar_t *pwcs, const char *s, size_t n )
1759{
1760 dprintf(("CRTDLL: mbstowcs(%08xh, %08xh, %08xh)\n", pwcs, s, n));
1761 return (mbstowcs(pwcs, s, n));
1762}
1763
1764
1765/*****************************************************************************
1766 * Name :
1767 * Purpose :
1768 * Parameters:
1769 * Variables :
1770 * Result :
1771 * Remark : NTDLL.903
1772 * Status :
1773 *
1774 * Author : Jens Wiessner
1775 *****************************************************************************/
1776
1777void * CDECL CRTDLL_memchr( const void *s, int c, size_t n )
1778{
1779 dprintf(("CRTDLL: memchr(%08xh, %08xh, %08xh)\n", s, c, n));
1780 return memchr( s, c, n );
1781}
1782
1783
1784/*****************************************************************************
1785 * Name :
1786 * Purpose :
1787 * Parameters:
1788 * Variables :
1789 * Result :
1790 * Remark : NTDLL.904
1791 * Status :
1792 *
1793 * Author : Jens Wiessner
1794 *****************************************************************************/
1795
1796int CDECL CRTDLL_memcmp( const void * c1, const void * c2, size_t n )
1797{
1798 dprintf(("CRTDLL: memcmp(%08xh, %08xh, %08xh)\n", c1, c2, n));
1799 return memcmp( c1, c2, n );
1800}
1801
1802/*****************************************************************************
1803 * Name :
1804 * Purpose :
1805 * Parameters:
1806 * Variables :
1807 * Result :
1808 * Remark : NTDLL.905
1809 * Status :
1810 *
1811 * Author : Jens Wiessner
1812 *****************************************************************************/
1813
1814void * CDECL CRTDLL_memcpy( void *s1, const void *s2, size_t n )
1815{
1816 dprintf(("CRTDLL: memcpy(%08xh, %08xh, %08xh)\n", s1, s2, n));
1817 return memcpy( s1, s2, n );
1818}
1819
1820
1821/*****************************************************************************
1822 * Name :
1823 * Purpose :
1824 * Parameters:
1825 * Variables :
1826 * Result :
1827 * Remark : NTDLL.907
1828 * Status :
1829 *
1830 * Author : Jens Wiessner
1831 *****************************************************************************/
1832
1833void * CDECL CRTDLL_memset( void *s, int i, size_t n )
1834{
1835 dprintf(("CRTDLL: memset(%08xh, %08xh, %08xh)\n", s, i, n));
1836 return memset( s, i, n );
1837}
1838//******************************************************************************
1839VOID CDECL CRTDLL_memmove(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, DWORD Length)
1840{
1841 memmove(Destination, Source, Length);
1842}
1843//******************************************************************************
1844
1845/*****************************************************************************
1846 * Name :
1847 * Purpose :
1848 * Parameters:
1849 * Variables :
1850 * Result :
1851 * Remark : NTDLL.908
1852 * Status :
1853 *
1854 * Author : Jens Wiessner
1855 *****************************************************************************/
1856
1857double CDECL CRTDLL_pow( double x, double y )
1858{
1859 dprintf(("CRTDLL: pow(%08xh, %08xh)\n",x, y));
1860 return pow( x, y );
1861}
1862
1863
1864
1865/*****************************************************************************
1866 * Name :
1867 * Purpose :
1868 * Parameters:
1869 * Variables :
1870 * Result :
1871 * Remark : NTDLL.910
1872 * Status :
1873 *
1874 * Author : Jens Wiessner
1875 *****************************************************************************/
1876
1877double CDECL CRTDLL_sin( double x )
1878{
1879 dprintf(("CRTDLL: sin(%08xh)\n", x));
1880 return (sin(x));
1881}
1882
1883
1884/*****************************************************************************
1885 * Name :
1886 * Purpose :
1887 * Parameters:
1888 * Variables :
1889 * Result :
1890 * Remark : NTDLL.912
1891 * Status :
1892 *
1893 * Author : Jens Wiessner
1894 *****************************************************************************/
1895
1896double CDECL CRTDLL_sqrt( double x )
1897{
1898 dprintf(("CRTDLL: sqrt(%08xh)\n", x));
1899 return (sqrt(x));
1900}
1901
1902
1903
1904/*****************************************************************************
1905 * Name :
1906 * Purpose :
1907 * Parameters:
1908 * Variables :
1909 * Result :
1910 * Remark : NTDLL.913
1911 * Status :
1912 *
1913 * Author : Jens Wiessner
1914 *****************************************************************************/
1915
1916int CDECL CRTDLL_sscanf( const char *s, const char *format, ... )
1917{
1918 dprintf(("CRTDLL: sscanf(%08xh, %08xh) not implemented.\n"));
1919 return 0;
1920}
1921
1922
1923/*****************************************************************************
1924 * Name :
1925 * Purpose :
1926 * Parameters:
1927 * Variables :
1928 * Result :
1929 * Remark : NTDLL.933
1930 * Status :
1931 *
1932 * Author : Jens Wiessner
1933 *****************************************************************************/
1934
1935int CDECL CRTDLL_vsprintf( char *s, const char *format, va_list arg )
1936{
1937 dprintf(("CRTDLL: vsprintf(%08xh, %08xh)\n", s, format));
1938 return (vsprintf(s, format, arg));
1939}
1940
1941
1942/*****************************************************************************
1943 * Name :
1944 * Purpose :
1945 * Parameters:
1946 * Variables :
1947 * Result :
1948 * Remark : NTDLL.947
1949 * Status :
1950 *
1951 * Author : Jens Wiessner
1952 *****************************************************************************/
1953
1954wchar_t * CDECL CRTDLL_wcstok( wchar_t *s1, const wchar_t *s2, wchar_t **ptr )
1955{
1956 dprintf(("CRTDLL: wcstok(%08xh, %08xh, %08xh)\n",s1,s2,ptr));
1957 return (wcstok(s1, s2, ptr));
1958}
1959
1960/*****************************************************************************
1961 * Name :
1962 * Purpose :
1963 * Parameters:
1964 * Variables :
1965 * Result :
1966 * Remark : NTDLL.948
1967 * Status :
1968 *
1969 * Author : Jens Wiessner
1970 *****************************************************************************/
1971
1972long int CDECL CRTDLL_wcstol( const wchar_t *s1, wchar_t **s2, int i )
1973{
1974 dprintf(("CRTDLL: wcstol(%08xh, %08xh, %08xh)\n",s1,s2,i));
1975 return (wcstol(s1, s2, i));
1976}
1977
1978
1979/*****************************************************************************
1980 * Name :
1981 * Purpose :
1982 * Parameters:
1983 * Variables :
1984 * Result :
1985 * Remark : NTDLL.949
1986 * Status :
1987 *
1988 * Author : Jens Wiessner
1989 *****************************************************************************/
1990
1991size_t CDECL CRTDLL_wcstombs( char *s, const wchar_t *pwcs, size_t n )
1992{
1993 dprintf(("CRTDLL: wcstombs(%08xh, %08xh, %08xh)\n",s,pwcs,n));
1994 return (wcstombs(s, pwcs, n));
1995}
1996
1997
1998/*****************************************************************************
1999 * Name :
2000 * Purpose :
2001 * Parameters:
2002 * Variables :
2003 * Result :
2004 * Remark : NTDLL.950
2005 * Status :
2006 *
2007 * Author : Jens Wiessner
2008 *****************************************************************************/
2009
2010unsigned long int CDECL CRTDLL_wcstoul( const wchar_t *s1, wchar_t **s2, int i )
2011{
2012 dprintf(("CRTDLL: wcstoul(%08xh, %08xh, %08xh)\n",s1,s2,i));
2013 return (wcstoul(s1, s2, i));
2014}
2015
2016
2017/*****************************************************************************
2018 * Name :
2019 * Purpose :
2020 * Parameters:
2021 * Variables :
2022 * Result :
2023 * Remark : NTDLL.983
2024 * Status :
2025 *
2026 * Author : Jens Wiessner
2027 *****************************************************************************/
2028
2029int CDECL CRTDLL__wtoi( const wchar_t *s )
2030{
2031 dprintf(("CRTDLL: _wtoi(%08xh) not implemented.\n"));
2032 return 0;
2033}
2034
2035
2036/*****************************************************************************
2037 * Name :
2038 * Purpose :
2039 * Parameters:
2040 * Variables :
2041 * Result :
2042 * Remark : NTDLL.984
2043 * Status :
2044 *
2045 * Author : Jens Wiessner
2046 *****************************************************************************/
2047
2048long int CDECL CRTDLL__wtol( const wchar_t *s )
2049{
2050 dprintf(("CRTDLL: _wtol(%08xh) not implemented.\n"));
2051 return 0;
2052}
Note: See TracBrowser for help on using the repository browser.