source: trunk/src/NTDLL/crt.cpp@ 2159

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

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