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

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

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