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

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

Fixed many register based floating point exports
File size: 49.1 KB
Line 
1/* $Id: crt.cpp,v 1.5 2000-01-08 14:24:03 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 * _CIacos (CRTDLL.004)
1323 */
1324double CDECL CRTDLL__CIacos()
1325{
1326 double x;
1327
1328 dprintf2(("CRTDLL: _CIacos\n"));
1329 POP_FPU(x);
1330 return acos(x);
1331}
1332
1333
1334/*********************************************************************
1335 * _CIasin (CRTDLL.005)
1336 */
1337double CDECL CRTDLL__CIasin()
1338{
1339 double x;
1340
1341 dprintf2(("CRTDLL: _CIasin\n"));
1342 POP_FPU(x);
1343 return asin(x);
1344}
1345
1346
1347/*********************************************************************
1348 * _CIatan (CRTDLL.006)
1349 */
1350double CDECL CRTDLL__CIatan()
1351{
1352 double x;
1353
1354 dprintf2(("CRTDLL: _CIatan\n"));
1355 POP_FPU(x);
1356 return atan(x);
1357}
1358
1359
1360/*********************************************************************
1361 * _CIatan2 (CRTDLL.007)
1362 */
1363double CDECL CRTDLL__CIatan2()
1364{
1365 double x, y;
1366
1367 dprintf2(("CRTDLL: _CIatan2\n"));
1368 POP_FPU(y);
1369 POP_FPU(x);
1370 return atan2(x,y);
1371}
1372
1373
1374/*********************************************************************
1375 * _CIcos (CRTDLL.008)
1376 */
1377double CDECL CRTDLL__CIcos()
1378{
1379 double x;
1380
1381 dprintf2(("CRTDLL: _CIcos\n"));
1382 POP_FPU(x);
1383 return cos(x);
1384}
1385
1386
1387/*********************************************************************
1388 * _CIcosh (CRTDLL.009)
1389 */
1390double CDECL CRTDLL__CIcosh()
1391{
1392 double x;
1393
1394 dprintf2(("CRTDLL: _CIcosh\n"));
1395 POP_FPU(x);
1396 return cosh(x);
1397}
1398
1399
1400/*********************************************************************
1401 * _CIexp (CRTDLL.010)
1402 */
1403double CDECL CRTDLL__CIexp()
1404{
1405 double x;
1406
1407 dprintf2(("CRTDLL: _CIexp\n"));
1408 POP_FPU(x);
1409 return exp(x);
1410}
1411
1412
1413/*********************************************************************
1414 * _CIfmod (CRTDLL.011)
1415 */
1416double CDECL CRTDLL__CIfmod( )
1417{
1418 double x, y;
1419
1420 dprintf2(("CRTDLL: _CIfmod\n"));
1421 POP_FPU(y);
1422 POP_FPU(x);
1423 return fmod(x,y);
1424}
1425
1426
1427/*********************************************************************
1428 * _CIlog (CRTDLL.012)
1429 */
1430double CDECL CRTDLL__CIlog()
1431{
1432 double x;
1433
1434 dprintf2(("CRTDLL: _CIlog\n"));
1435 POP_FPU(x);
1436 return log(x);
1437}
1438
1439
1440/*********************************************************************
1441 * _CIlog10 (CRTDLL.013)
1442 */
1443double CDECL CRTDLL__CIlog10()
1444{
1445 double x;
1446
1447 dprintf2(("CRTDLL: _CIlog10\n"));
1448 POP_FPU(x);
1449 return log10(x);
1450}
1451
1452
1453/*********************************************************************
1454 * _CIsin (CRTDLL.015)
1455 */
1456double CDECL CRTDLL__CIsin()
1457{
1458 double x;
1459
1460 dprintf2(("CRTDLL: _CIsin\n"));
1461 POP_FPU(x);
1462 return sin(x);
1463}
1464
1465
1466/*********************************************************************
1467 * _CIsinh (CRTDLL.016)
1468 */
1469double CDECL CRTDLL__CIsinh()
1470{
1471 double x;
1472
1473 dprintf2(("CRTDLL: _CIsinh\n"));
1474 POP_FPU(x);
1475 return sinh(x);
1476}
1477
1478
1479/*********************************************************************
1480 * _CIsqrt (CRTDLL.017)
1481 */
1482double CDECL CRTDLL__CIsqrt()
1483{
1484 double x;
1485
1486 dprintf2(("CRTDLL: _CIsqrt\n"));
1487 POP_FPU(x);
1488 return sqrt(x);
1489}
1490
1491
1492/*********************************************************************
1493 * _CItan (CRTDLL.018)
1494 */
1495double CDECL CRTDLL__CItan()
1496{
1497 double x;
1498
1499 dprintf2(("CRTDLL: _CItan\n"));
1500 POP_FPU(x);
1501 return tan(x);
1502}
1503
1504
1505/*********************************************************************
1506 * _CItanh (CRTDLL.019)
1507 */
1508double CDECL CRTDLL__CItanh()
1509{
1510 double x;
1511
1512 dprintf2(("CRTDLL: _CItanh\n"));
1513 POP_FPU(x);
1514 return tanh(x);
1515}
1516
1517
1518/*****************************************************************************
1519 * Name :
1520 * Purpose :
1521 * Parameters:
1522 * Variables :
1523 * Result :
1524 * Remark : NTDLL.864
1525 * Status :
1526 *
1527 * Author : Jens Wiessner
1528 *****************************************************************************/
1529
1530LONG CDECL CRTDLL__ftol(void)
1531{
1532 /* don't just do DO_FPU("fistp",retval), because the rounding
1533 * mode must also be set to "round towards zero"... */
1534 double fl;
1535 POP_FPU(fl);
1536 return (LONG)fl;
1537}
1538
1539
1540/*****************************************************************************
1541 * Name :
1542 * Purpose :
1543 * Parameters:
1544 * Variables :
1545 * Result :
1546 * Remark : NTDLL.866
1547 * Status :
1548 *
1549 * Author : Jens Wiessner
1550 *****************************************************************************/
1551
1552LPSTR CDECL CRTDLL__ltoa(long x,LPSTR buf,INT radix)
1553{
1554 return ltoa(x,buf,radix);
1555}
1556
1557
1558/*****************************************************************************
1559 * Name :
1560 * Purpose :
1561 * Parameters:
1562 * Variables :
1563 * Result :
1564 * Remark : NTDLL.868
1565 * Status :
1566 *
1567 * Author : Jens Wiessner
1568 *****************************************************************************/
1569
1570INT CDECL CRTDLL__memicmp(
1571 LPCSTR s1, /* [in] first string */
1572 LPCSTR s2, /* [in] second string */
1573 DWORD len /* [in] length to compare */ )
1574{
1575 dprintf2(("CRTDLL: memicmp(%08xh, %08xh, %08xh)\n",s1,s2,len));
1576 int i;
1577
1578 for (i=0;i<len;i++) {
1579 if (tolower(s1[i])<tolower(s2[i]))
1580 return -1;
1581 if (tolower(s1[i])>tolower(s2[i]))
1582 return 1;
1583 }
1584 return 0;
1585}
1586
1587
1588/*****************************************************************************
1589 * Name :
1590 * Purpose :
1591 * Parameters:
1592 * Variables :
1593 * Result :
1594 * Remark : NTDLL.869
1595 * Status :
1596 *
1597 * Author : Jens Wiessner
1598 *****************************************************************************/
1599
1600int CDECL CRTDLL__snprintf( char *buf, size_t bufsize, const char *fmt, ... )
1601{
1602 dprintf(("CRTDLL: _snprintf(%08xh, %08xh, %08xh) not implemented\n",
1603 buf,
1604 bufsize,
1605 fmt));
1606
1607 return 0;
1608}
1609
1610
1611/*****************************************************************************
1612 * Name :
1613 * Purpose :
1614 * Parameters:
1615 * Variables :
1616 * Result :
1617 * Remark : NTDLL.870
1618 * Status :
1619 *
1620 * Author : Jens Wiessner
1621 *****************************************************************************/
1622
1623int CDECL CRTDLL__snwprintf( wchar_t *buf, size_t bufsize, const wchar_t *fmt, ... )
1624{
1625 dprintf(("CRTDLL: _snwprintf(%08xh, %08xh, %08xh) not implemented\n",
1626 buf,
1627 bufsize,
1628 fmt));
1629
1630 return 0;
1631}
1632
1633
1634/*****************************************************************************
1635 * Name :
1636 * Purpose :
1637 * Parameters:
1638 * Variables :
1639 * Result :
1640 * Remark : NTDLL.871
1641 * Status :
1642 *
1643 * Author : Jens Wiessner
1644 *****************************************************************************/
1645
1646void CDECL CRTDLL__splitpath( const char *path, char *drive, char *dir, char *fname, char *ext )
1647{
1648 dprintf2(("CRTDLL: _splitpath"));
1649
1650 char *tmp_drive;
1651 char *tmp_dir;
1652 char *tmp_ext;
1653
1654 tmp_drive = (char *)strchr(path,':');
1655 if ( tmp_drive != (char *)NULL ) {
1656 strncpy(drive,tmp_drive-1,1);
1657 *(drive+1) = 0;
1658 }
1659 else {
1660 *drive = 0;
1661 tmp_drive = (char *)path;
1662 }
1663
1664 tmp_dir = (char *)strrchr(path,'\\');
1665 if( tmp_dir != NULL && tmp_dir != tmp_drive + 1 ) {
1666 strncpy(dir,tmp_drive+1,tmp_dir - tmp_drive);
1667 *(dir + (tmp_dir - tmp_drive)) = 0;
1668 }
1669 else
1670 *dir =0;
1671
1672 tmp_ext = ( char *)strrchr(path,'.');
1673 if ( tmp_ext != NULL ) {
1674 strcpy(ext,tmp_ext);
1675 }
1676 else
1677 *ext = 0;
1678 if ( tmp_dir != NULL ) {
1679 strncpy(fname,tmp_dir+1,tmp_ext - tmp_dir - 1);
1680 *(fname + (tmp_ext - tmp_dir -1)) = 0;
1681 }
1682 else
1683 strncpy(fname,path,tmp_ext - path);
1684
1685}
1686
1687
1688/*****************************************************************************
1689 * Name :
1690 * Purpose :
1691 * Parameters:
1692 * Variables :
1693 * Result :
1694 * Remark : NTDLL.872
1695 * Status :
1696 *
1697 * Author : Jens Wiessner
1698 *****************************************************************************/
1699
1700void CDECL CRTDLL__strcmpi( LPCSTR s1, LPCSTR s2 )
1701{
1702 dprintf2(("CRTDLL: _strcmpi(%08xh, %08xh)\n",
1703 s1,
1704 s2));
1705
1706 lstrcmpiA( s1, s2 );
1707}
1708
1709
1710/*****************************************************************************
1711 * Name :
1712 * Purpose :
1713 * Parameters:
1714 * Variables :
1715 * Result :
1716 * Remark : NTDLL.874
1717 * Status :
1718 *
1719 * Author : Jens Wiessner
1720 *****************************************************************************/
1721
1722CHAR * CDECL CRTDLL__strlwr(char *x)
1723{
1724 char *y =x;
1725
1726 dprintf2(("CRTDLL: _strlwr got %s\n", x));
1727 while (*y) {
1728 if ((*y > 0x40) && (*y< 0x5b))
1729 *y = *y + 0x20;
1730 y++;
1731 }
1732 dprintf2((" returned %s\n", x));
1733
1734 return x;
1735}
1736
1737
1738/*****************************************************************************
1739 * Name :
1740 * Purpose :
1741 * Parameters:
1742 * Variables :
1743 * Result :
1744 * Remark : NTDLL.875
1745 * Status :
1746 *
1747 * Author : Jens Wiessner
1748 *****************************************************************************/
1749
1750int CDECL CRTDLL__strnicmp( LPCSTR s1, LPCSTR s2, INT n )
1751{
1752 dprintf2(("CRTDLL: _strnicmp (%s,%s,%d)\n",
1753 s1,
1754 s2,
1755 n));
1756
1757 // @@@PH: sure it's not a UNICODE API?
1758 return (lstrncmpiA(s1,s2,n));
1759
1760/*
1761 if (n == 0)
1762 return 0;
1763 do {
1764 if (toupper(*s1) != toupper(*s2++))
1765 return toupper(*(unsigned const char *)s1) - toupper(*(unsigned const char *)--s2);
1766 if (*s1++ == 0)
1767 break;
1768 } while (--n != 0);
1769 return 0;
1770*/
1771}
1772
1773
1774/*****************************************************************************
1775 * Name :
1776 * Purpose :
1777 * Parameters:
1778 * Variables :
1779 * Result :
1780 * Remark : NTDLL.876
1781 * Status :
1782 *
1783 * Author : Jens Wiessner
1784 *****************************************************************************/
1785
1786LPSTR CDECL CRTDLL__strupr(LPSTR x)
1787{
1788 dprintf2(("CRTDLL: _strupr(%s)\n",
1789 x));
1790
1791 LPSTR y=x;
1792
1793 while (*y)
1794 {
1795 *y=toupper(*y);
1796 y++;
1797 }
1798 return x;
1799}
1800
1801
1802/*****************************************************************************
1803 * Name :
1804 * Purpose :
1805 * Parameters:
1806 * Variables :
1807 * Result :
1808 * Remark : NTDLL.877
1809 * Status :
1810 *
1811 * Author : Jens Wiessner
1812 *****************************************************************************/
1813
1814LPSTR CDECL CRTDLL__ultoa(long x,LPSTR buf,INT radix)
1815{
1816 return ultoa(x,buf,radix);
1817}
1818
1819
1820/*****************************************************************************
1821 * Name :
1822 * Purpose :
1823 * Parameters:
1824 * Variables :
1825 * Result :
1826 * Remark : NTDLL.878
1827 * Status :
1828 *
1829 * Author : Jens Wiessner
1830 *****************************************************************************/
1831
1832int CDECL CRTDLL__vsnprintf( char *s, size_t bufsize, const char *format, va_list arg )
1833{
1834 dprintf2(("CRTDLL: _vsnprintf(%08xh, %08xh, %08xh)\n",
1835 s,
1836 bufsize,
1837 format));
1838
1839 return wvsnprintfA(s, bufsize, format, arg);
1840}
1841
1842
1843/*****************************************************************************
1844 * Name :
1845 * Purpose :
1846 * Parameters:
1847 * Variables :
1848 * Result :
1849 * Remark : NTDLL.897
1850 * Status :
1851 *
1852 * Author : Jens Wiessner
1853 *****************************************************************************/
1854
1855int CDECL CRTDLL_iswalpha(wint_t i)
1856{
1857 dprintf2(("CRTDLL: iswalpha(%08xh)\n", i));
1858
1859 return (iswalpha(i));
1860}
1861
1862
1863/*****************************************************************************
1864 * Name :
1865 * Purpose :
1866 * Parameters:
1867 * Variables :
1868 * Result :
1869 * Remark : NTDLL.898
1870 * Status :
1871 *
1872 * Author : Jens Wiessner
1873 *****************************************************************************/
1874
1875int CDECL CRTDLL_iswctype(wint_t i, wctype_t wct)
1876{
1877 dprintf2(("CRTDLL: iswctype(%08xh, %08xh)\n", i, wct));
1878
1879 return (iswctype(i, wct));
1880}
1881
1882
1883/*****************************************************************************
1884 * Name :
1885 * Purpose :
1886 * Parameters:
1887 * Variables :
1888 * Result :
1889 * Remark : NTDLL.899
1890 * Status :
1891 *
1892 * Author : Jens Wiessner
1893 *****************************************************************************/
1894
1895int CDECL CRTDLL_isxdigit(int i)
1896{
1897 dprintf2(("CRTDLL: isxdigit(%08xh)\n", i));
1898
1899 return (isxdigit(i));
1900}
1901
1902
1903/*****************************************************************************
1904 * Name :
1905 * Purpose :
1906 * Parameters:
1907 * Variables :
1908 * Result :
1909 * Remark : NTDLL.900
1910 * Status :
1911 *
1912 * Author : Jens Wiessner
1913 *****************************************************************************/
1914
1915long int CDECL CRTDLL_labs( long int j )
1916{
1917 dprintf2(("CRTDLL: labs(%08xh)\n", j));
1918
1919 return (labs(j));
1920}
1921
1922
1923/*****************************************************************************
1924 * Name :
1925 * Purpose :
1926 * Parameters:
1927 * Variables :
1928 * Result :
1929 * Remark : NTDLL.901
1930 * Status :
1931 *
1932 * Author : Jens Wiessner
1933 *****************************************************************************/
1934
1935double CDECL CRTDLL_log( double x )
1936{
1937 dprintf2(("CRTDLL: log(%08xh)\n", x));
1938 return (log(x));
1939}
1940
1941
1942/*****************************************************************************
1943 * Name :
1944 * Purpose :
1945 * Parameters:
1946 * Variables :
1947 * Result :
1948 * Remark : NTDLL.902
1949 * Status :
1950 *
1951 * Author : Jens Wiessner
1952 *****************************************************************************/
1953
1954size_t CDECL CRTDLL_mbstowcs( wchar_t *pwcs, const char *s, size_t n )
1955{
1956 dprintf2(("CRTDLL: mbstowcs(%08xh, %08xh, %08xh)\n", pwcs, s, n));
1957 return (mbstowcs(pwcs, s, n));
1958}
1959
1960
1961/*****************************************************************************
1962 * Name :
1963 * Purpose :
1964 * Parameters:
1965 * Variables :
1966 * Result :
1967 * Remark : NTDLL.903
1968 * Status :
1969 *
1970 * Author : Jens Wiessner
1971 *****************************************************************************/
1972
1973void * CDECL CRTDLL_memchr( const void *s, int c, size_t n )
1974{
1975 dprintf2(("CRTDLL: memchr(%08xh, %08xh, %08xh)\n", s, c, n));
1976 return memchr( s, c, n );
1977}
1978
1979
1980/*****************************************************************************
1981 * Name :
1982 * Purpose :
1983 * Parameters:
1984 * Variables :
1985 * Result :
1986 * Remark : NTDLL.904
1987 * Status :
1988 *
1989 * Author : Jens Wiessner
1990 *****************************************************************************/
1991
1992int CDECL CRTDLL_memcmp( const void * c1, const void * c2, size_t n )
1993{
1994 dprintf2(("CRTDLL: memcmp(%08xh, %08xh, %08xh)\n", c1, c2, n));
1995 return memcmp( c1, c2, n );
1996}
1997
1998/*****************************************************************************
1999 * Name :
2000 * Purpose :
2001 * Parameters:
2002 * Variables :
2003 * Result :
2004 * Remark : NTDLL.905
2005 * Status :
2006 *
2007 * Author : Jens Wiessner
2008 *****************************************************************************/
2009
2010void * CDECL CRTDLL_memcpy( void *s1, const void *s2, size_t n )
2011{
2012 dprintf2(("CRTDLL: memcpy(%08xh, %08xh, %08xh)\n", s1, s2, n));
2013 return memcpy( s1, s2, n );
2014}
2015
2016
2017/*****************************************************************************
2018 * Name :
2019 * Purpose :
2020 * Parameters:
2021 * Variables :
2022 * Result :
2023 * Remark : NTDLL.907
2024 * Status :
2025 *
2026 * Author : Jens Wiessner
2027 *****************************************************************************/
2028
2029void * CDECL CRTDLL_memset( void *s, int i, size_t n )
2030{
2031 dprintf2(("CRTDLL: memset(%08xh, %08xh, %08xh)\n", s, i, n));
2032 return memset( s, i, n );
2033}
2034//******************************************************************************
2035VOID CDECL CRTDLL_memmove(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, DWORD Length)
2036{
2037 memmove(Destination, Source, Length);
2038}
2039//******************************************************************************
2040
2041/*****************************************************************************
2042 * Name :
2043 * Purpose :
2044 * Parameters:
2045 * Variables :
2046 * Result :
2047 * Remark : NTDLL.908
2048 * Status :
2049 *
2050 * Author : Jens Wiessner
2051 *****************************************************************************/
2052
2053double CDECL CRTDLL_pow( double x, double y )
2054{
2055 dprintf2(("CRTDLL: pow(%08xh, %08xh)\n",x, y));
2056 return pow( x, y );
2057}
2058
2059
2060
2061/*****************************************************************************
2062 * Name :
2063 * Purpose :
2064 * Parameters:
2065 * Variables :
2066 * Result :
2067 * Remark : NTDLL.910
2068 * Status :
2069 *
2070 * Author : Jens Wiessner
2071 *****************************************************************************/
2072
2073double CDECL CRTDLL_sin( double x )
2074{
2075 dprintf2(("CRTDLL: sin(%08xh)\n", x));
2076 return (sin(x));
2077}
2078
2079
2080/*****************************************************************************
2081 * Name :
2082 * Purpose :
2083 * Parameters:
2084 * Variables :
2085 * Result :
2086 * Remark : NTDLL.912
2087 * Status :
2088 *
2089 * Author : Jens Wiessner
2090 *****************************************************************************/
2091
2092double CDECL CRTDLL_sqrt( double x )
2093{
2094 dprintf2(("CRTDLL: sqrt(%08xh)\n", x));
2095 return (sqrt(x));
2096}
2097
2098
2099
2100/*****************************************************************************
2101 * Name :
2102 * Purpose :
2103 * Parameters:
2104 * Variables :
2105 * Result :
2106 * Remark : NTDLL.913
2107 * Status :
2108 *
2109 * Author : Jens Wiessner
2110 *****************************************************************************/
2111
2112int CDECL CRTDLL_sscanf( const char *s, const char *format, ... )
2113{
2114 dprintf(("CRTDLL: sscanf(%08xh, %08xh) not implemented.\n"));
2115 return 0;
2116}
2117
2118
2119/*****************************************************************************
2120 * Name :
2121 * Purpose :
2122 * Parameters:
2123 * Variables :
2124 * Result :
2125 * Remark : NTDLL.933
2126 * Status :
2127 *
2128 * Author : Jens Wiessner
2129 *****************************************************************************/
2130
2131int CDECL CRTDLL_vsprintf( char *s, const char *format, va_list arg )
2132{
2133 dprintf2(("CRTDLL: vsprintf(%08xh, %08xh)\n", s, format));
2134 return (vsprintf(s, format, arg));
2135}
2136
2137
2138/*****************************************************************************
2139 * Name :
2140 * Purpose :
2141 * Parameters:
2142 * Variables :
2143 * Result :
2144 * Remark : NTDLL.947
2145 * Status :
2146 *
2147 * Author : Jens Wiessner
2148 *****************************************************************************/
2149
2150wchar_t * CDECL CRTDLL_wcstok( wchar_t *s1, const wchar_t *s2, wchar_t **ptr )
2151{
2152 dprintf2(("CRTDLL: wcstok(%08xh, %08xh, %08xh)\n",s1,s2,ptr));
2153 return (wcstok(s1, s2, ptr));
2154}
2155
2156/*****************************************************************************
2157 * Name :
2158 * Purpose :
2159 * Parameters:
2160 * Variables :
2161 * Result :
2162 * Remark : NTDLL.948
2163 * Status :
2164 *
2165 * Author : Jens Wiessner
2166 *****************************************************************************/
2167
2168long int CDECL CRTDLL_wcstol( const wchar_t *s1, wchar_t **s2, int i )
2169{
2170 dprintf2(("CRTDLL: wcstol(%08xh, %08xh, %08xh)\n",s1,s2,i));
2171 return (wcstol(s1, s2, i));
2172}
2173
2174
2175/*****************************************************************************
2176 * Name :
2177 * Purpose :
2178 * Parameters:
2179 * Variables :
2180 * Result :
2181 * Remark : NTDLL.949
2182 * Status :
2183 *
2184 * Author : Jens Wiessner
2185 *****************************************************************************/
2186
2187size_t CDECL CRTDLL_wcstombs( char *s, const wchar_t *pwcs, size_t n )
2188{
2189 dprintf2(("CRTDLL: wcstombs(%08xh, %08xh, %08xh)\n",s,pwcs,n));
2190 return (wcstombs(s, pwcs, n));
2191}
2192
2193
2194/*****************************************************************************
2195 * Name :
2196 * Purpose :
2197 * Parameters:
2198 * Variables :
2199 * Result :
2200 * Remark : NTDLL.950
2201 * Status :
2202 *
2203 * Author : Jens Wiessner
2204 *****************************************************************************/
2205
2206unsigned long int CDECL CRTDLL_wcstoul( const wchar_t *s1, wchar_t **s2, int i )
2207{
2208 dprintf2(("CRTDLL: wcstoul(%08xh, %08xh, %08xh)\n",s1,s2,i));
2209 return (wcstoul(s1, s2, i));
2210}
2211
2212
2213/*****************************************************************************
2214 * Name :
2215 * Purpose :
2216 * Parameters:
2217 * Variables :
2218 * Result :
2219 * Remark : NTDLL.983
2220 * Status :
2221 *
2222 * Author : Jens Wiessner
2223 *****************************************************************************/
2224
2225int CDECL CRTDLL__wtoi( const wchar_t *s )
2226{
2227 dprintf(("CRTDLL: _wtoi(%08xh) not implemented.\n"));
2228 return 0;
2229}
2230
2231
2232/*****************************************************************************
2233 * Name :
2234 * Purpose :
2235 * Parameters:
2236 * Variables :
2237 * Result :
2238 * Remark : NTDLL.984
2239 * Status :
2240 *
2241 * Author : Jens Wiessner
2242 *****************************************************************************/
2243
2244long int CDECL CRTDLL__wtol( const wchar_t *s )
2245{
2246 dprintf(("CRTDLL: _wtol(%08xh) not implemented.\n"));
2247 return 0;
2248}
Note: See TracBrowser for help on using the repository browser.