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

Last change on this file since 1036 was 927, checked in by phaller, 26 years ago

Add: more CRT functions
File size: 44.6 KB
Line 
1/* $Id: crt.cpp,v 1.9 1999-09-13 19:45:33 phaller 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
26/*
27NTDLL.sprintf
28NTDLL._wcsicmp
29*/
30
31
32/****************************************************************************
33 * Local Prototypes *
34 ****************************************************************************/
35
36
37LPWSTR CDECL OS2_wcsupr(LPWSTR str);
38int CDECL OS2_wcsnicmp(LPWSTR str1, LPWSTR str2, long l);
39
40
41
42/*****************************************************************************
43 * Name :
44 * Purpose :
45 * Parameters:
46 * Variables :
47 * Result :
48 * Remark : NTDLL.879
49 * Status :
50 *
51 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
52 *****************************************************************************/
53
54int CDECL OS2_wcsicmp(LPWSTR str1, LPWSTR str2)
55{
56 dprintf(("NTDLL: _wcsicmp(%08xh,%08xh)\n",
57 str1,
58 str2));
59
60 return (OS2_wcsnicmp(str1,
61 str2,
62 wcslen((wchar_t*) str1)));
63}
64
65
66/*****************************************************************************
67 * Name :
68 * Purpose :
69 * Parameters:
70 * Variables :
71 * Result :
72 * Remark : NTDLL.880
73 * Status :
74 *
75 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
76 *****************************************************************************/
77
78LPWSTR CDECL OS2_wcslwr(LPWSTR str)
79{
80 DWORD dwIndex;
81
82 dprintf(("NTDLL: _wcslwr(%08xh)\n",
83 str));
84
85 for (dwIndex = wcslen((const wchar_t*)str);
86 dwIndex;
87 dwIndex--)
88 {
89 towlower(str[dwIndex]);
90 }
91
92 return (str);
93}
94
95
96/*****************************************************************************
97 * Name :
98 * Purpose :
99 * Parameters:
100 * Variables :
101 * Result :
102 * Remark : NTDLL.881
103 * Status :
104 *
105 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
106 *****************************************************************************/
107
108int CDECL OS2_wcsnicmp(LPWSTR str1, LPWSTR str2, long l)
109{
110 LPWSTR w1;
111 LPWSTR w2;
112
113 dprintf(("NTDLL: _wcsnicmp(%08xh,%08xh,%08xh)\n",
114 str1,
115 str2,
116 l));
117
118 w1 = HEAP_strdupW(GetProcessHeap(),0,str1);
119 w2 = HEAP_strdupW(GetProcessHeap(),0,str2);
120 OS2_wcsupr(w1);
121 OS2_wcsupr(w2);
122
123 return (wcsncmp((wchar_t*)w1,
124 (wchar_t*)w2,
125 l));
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 OS2_wcsupr(LPWSTR str)
142{
143 DWORD dwIndex;
144
145 dprintf(("NTDLL: _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 OS2abs(double d)
173{
174 dprintf(("NTDLL: 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 OS2atan(double d)
194{
195 dprintf(("NTDLL: 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 OS2atoi(LPSTR str)
215{
216 dprintf(("NTDLL: 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 OS2atol(LPSTR str)
236{
237 dprintf(("NTDLL: 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 OS2ceil(double d)
257{
258 dprintf(("NTDLL: 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 OS2cos(double d)
278{
279 dprintf(("NTDLL: 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 OS2fabs(double d)
299{
300 dprintf(("NTDLL: 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 OS2floor(double d)
320{
321 dprintf(("NTDLL: 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 OS2isalpha(int i)
341{
342 dprintf(("NTDLL: 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 OS2isdigit(int i)
362{
363 dprintf(("NTDLL: 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 OS2islower(int i)
383{
384 dprintf(("NTDLL: 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 OS2isprint(int i)
404{
405 dprintf(("NTDLL: 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 OS2isspace(int i)
425{
426 dprintf(("NTDLL: 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 OS2isupper(int i)
446{
447 dprintf(("NTDLL: 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 OS2sprintf(LPSTR lpstrBuffer,
467 LPSTR lpstrFormat,
468 ...)
469{
470 va_list argptr; /* -> variable argument list */
471
472 dprintf(("NTDLL: 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 OS2strcat( LPSTR str1,
501 const LPSTR str2)
502{
503 dprintf(("NTDLL: strcat(%s,%s)\n",
504 str1,
505 str2));
506
507 return (strcat(str1, str2));
508}
509
510
511/*****************************************************************************
512 * Name :
513 * Purpose :
514 * Parameters:
515 * Variables :
516 * Result :
517 * Remark : NTDLL.915
518 * Status :
519 *
520 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
521 *****************************************************************************/
522
523LPSTR CDECL OS2strchr(const LPSTR str,
524 int i)
525{
526 dprintf(("NTDLL: strchr(%s,%08xh)\n",
527 str,
528 i));
529
530 return (strchr(str, i));
531}
532
533
534/*****************************************************************************
535 * Name :
536 * Purpose :
537 * Parameters:
538 * Variables :
539 * Result :
540 * Remark : NTDLL.916
541 * Status :
542 *
543 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
544 *****************************************************************************/
545
546int CDECL OS2strcmp(const LPSTR str1,
547 const LPSTR str2)
548{
549 dprintf(("NTDLL: strcmp(%s,%s)\n",
550 str1,
551 str2));
552
553 return (strcmp(str1, str2));
554}
555
556
557/*****************************************************************************
558 * Name :
559 * Purpose :
560 * Parameters:
561 * Variables :
562 * Result :
563 * Remark : NTDLL.?
564 * Status :
565 *
566 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
567 *****************************************************************************/
568
569int CDECL OS2_stricmp(const LPSTR str1,
570 const LPSTR str2)
571{
572 dprintf(("NTDLL: _stricmp(%s,%s)\n",
573 str1,
574 str2));
575
576 return (stricmp(str1, str2));
577}
578
579
580/*****************************************************************************
581 * Name :
582 * Purpose :
583 * Parameters:
584 * Variables :
585 * Result :
586 * Remark : NTDLL.917
587 * Status :
588 *
589 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
590 *****************************************************************************/
591
592LPSTR CDECL OS2strcpy( LPSTR str1,
593 const LPSTR str2)
594{
595 dprintf(("NTDLL: strcpy(%s,%s)\n",
596 str1,
597 str2));
598
599 return (strcpy(str1, str2));
600}
601
602
603/*****************************************************************************
604 * Name :
605 * Purpose :
606 * Parameters:
607 * Variables :
608 * Result :
609 * Remark : NTDLL.918
610 * Status :
611 *
612 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
613 *****************************************************************************/
614
615size_t CDECL OS2strcspn(const LPSTR str1,
616 LPSTR str2)
617{
618 dprintf(("NTDLL: strcspn(%s,%s)\n",
619 str1,
620 str2));
621
622 return (strcspn(str1, str2));
623}
624
625
626/*****************************************************************************
627 * Name :
628 * Purpose :
629 * Parameters:
630 * Variables :
631 * Result :
632 * Remark : NTDLL.919
633 * Status :
634 *
635 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
636 *****************************************************************************/
637
638size_t CDECL OS2strlen(const LPSTR str)
639{
640 dprintf(("NTDLL: strlen(%s)\n",
641 str));
642
643 return (strlen(str));
644}
645
646
647/*****************************************************************************
648 * Name :
649 * Purpose :
650 * Parameters:
651 * Variables :
652 * Result :
653 * Remark : NTDLL.920
654 * Status :
655 *
656 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
657 *****************************************************************************/
658
659LPSTR CDECL OS2strncat( LPSTR str1,
660 const LPSTR str2,
661 size_t i)
662{
663 dprintf(("NTDLL: strncat(%s,%s,%08xh)\n",
664 str1,
665 str2,
666 i));
667
668 return (strncat(str1, str2, i));
669}
670
671
672/*****************************************************************************
673 * Name :
674 * Purpose :
675 * Parameters:
676 * Variables :
677 * Result :
678 * Remark : NTDLL.921
679 * Status :
680 *
681 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
682 *****************************************************************************/
683
684int CDECL OS2strncmp(const LPSTR str1,
685 const LPSTR str2,
686 size_t i)
687{
688 dprintf(("NTDLL: strncmp(%s,%s,%08xh)\n",
689 str1,
690 str2,
691 i));
692
693 return (strncmp(str1, str2, i));
694}
695
696
697/*****************************************************************************
698 * Name :
699 * Purpose :
700 * Parameters:
701 * Variables :
702 * Result :
703 * Remark : NTDLL.922
704 * Status :
705 *
706 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
707 *****************************************************************************/
708
709LPSTR CDECL OS2strncpy(const LPSTR str1,
710 const LPSTR str2,
711 size_t i)
712{
713 dprintf(("NTDLL: strncpy(%s,%s,%08xh)\n",
714 str1,
715 str2,
716 i));
717
718 return (strncpy(str1, str2, i));
719}
720
721
722/*****************************************************************************
723 * Name :
724 * Purpose :
725 * Parameters:
726 * Variables :
727 * Result :
728 * Remark : NTDLL.923
729 * Status :
730 *
731 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
732 *****************************************************************************/
733
734LPSTR CDECL OS2strpbrk(const LPSTR str1,
735 const LPSTR str2)
736{
737 dprintf(("NTDLL: strpbrk(%s,%s)\n",
738 str1,
739 str2));
740
741 return (strpbrk(str1, str2));
742}
743
744
745/*****************************************************************************
746 * Name :
747 * Purpose :
748 * Parameters:
749 * Variables :
750 * Result :
751 * Remark : NTDLL.924
752 * Status :
753 *
754 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
755 *****************************************************************************/
756
757LPSTR CDECL OS2strrchr(const LPSTR str,
758 size_t i)
759{
760 dprintf(("NTDLL: strrchr(%s,%08xh)\n",
761 str,
762 i));
763
764 return (strrchr(str, i));
765}
766
767
768/*****************************************************************************
769 * Name :
770 * Purpose :
771 * Parameters:
772 * Variables :
773 * Result :
774 * Remark : NTDLL.925
775 * Status :
776 *
777 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
778 *****************************************************************************/
779
780size_t CDECL OS2strspn(const LPSTR str1,
781 const LPSTR str2)
782{
783 dprintf(("NTDLL: strspn(%s,%s)\n",
784 str1,
785 str2));
786
787 return (strspn(str1, str2));
788}
789
790
791/*****************************************************************************
792 * Name :
793 * Purpose :
794 * Parameters:
795 * Variables :
796 * Result :
797 * Remark : NTDLL.926
798 * Status :
799 *
800 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
801 *****************************************************************************/
802
803LPSTR CDECL OS2strstr(const LPSTR str1,
804 const LPSTR str2)
805{
806 dprintf(("NTDLL: strstr(%s,%s)\n",
807 str1,
808 str2));
809
810 return (strstr(str1, str2));
811}
812
813
814/*****************************************************************************
815 * Name :
816 * Purpose :
817 * Parameters:
818 * Variables :
819 * Result :
820 * Remark : NTDLL.927
821 * Status :
822 *
823 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
824 *****************************************************************************/
825
826int CDECL OS2swprintf(const LPWSTR str,
827 int i,
828 const LPWSTR format,
829 ...)
830{
831 va_list valist;
832 int rc;
833
834 dprintf(("NTDLL: swprintf(%s,%d,%s)\n",
835 str,
836 i,
837 format));
838
839 va_start( valist, format );
840 rc = vswprintf( (wchar_t*)str,
841 i,
842 (wchar_t*)format,
843 valist );
844 va_end( valist );
845 return rc;
846}
847
848
849/*****************************************************************************
850 * Name :
851 * Purpose :
852 * Parameters:
853 * Variables :
854 * Result :
855 * Remark : NTDLL.928
856 * Status :
857 *
858 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
859 *****************************************************************************/
860
861double CDECL OS2tan(double d)
862{
863 dprintf(("NTDLL: tan(%f)\n",
864 d));
865
866 return (tan(d));
867}
868
869
870/*****************************************************************************
871 * Name :
872 * Purpose :
873 * Parameters:
874 * Variables :
875 * Result :
876 * Remark : NTDLL.929
877 * Status :
878 *
879 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
880 *****************************************************************************/
881
882int CDECL OS2toupper(int c)
883{
884 dprintf(("NTDLL: toupper(%c)\n",
885 c));
886
887 return (toupper(c));
888}
889
890
891/*****************************************************************************
892 * Name :
893 * Purpose :
894 * Parameters:
895 * Variables :
896 * Result :
897 * Remark : NTDLL.930
898 * Status :
899 *
900 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
901 *****************************************************************************/
902
903int CDECL OS2tolower(int c)
904{
905 dprintf(("NTDLL: tolower(%c)\n",
906 c));
907
908 return (tolower(c));
909}
910
911
912/*****************************************************************************
913 * Name :
914 * Purpose :
915 * Parameters:
916 * Variables :
917 * Result :
918 * Remark : NTDLL.931
919 * Status :
920 *
921 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
922 *****************************************************************************/
923
924int CDECL OS2towupper(int c)
925{
926 dprintf(("NTDLL: towupper(%c)\n",
927 c));
928
929 return (towupper(c));
930}
931
932
933/*****************************************************************************
934 * Name :
935 * Purpose :
936 * Parameters:
937 * Variables :
938 * Result :
939 * Remark : NTDLL.932
940 * Status :
941 *
942 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
943 *****************************************************************************/
944
945int CDECL OS2towlower(int c)
946{
947 dprintf(("NTDLL: towlower(%c)\n",
948 c));
949
950 return (towlower(c));
951}
952
953
954
955/*****************************************************************************
956 * Name :
957 * Purpose :
958 * Parameters:
959 * Variables :
960 * Result :
961 * Remark : NTDLL.934
962 * Status :
963 *
964 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
965 *****************************************************************************/
966
967wchar_t* CDECL OS2wcscat( wchar_t* str1,
968 const wchar_t* str2)
969{
970 dprintf(("NTDLL: wcscat(%08xh,%08xh)\n",
971 str1,
972 str2));
973
974 return (wcscat(str1, str2));
975}
976
977
978/*****************************************************************************
979 * Name :
980 * Purpose :
981 * Parameters:
982 * Variables :
983 * Result :
984 * Remark : NTDLL.935
985 * Status :
986 *
987 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
988 *****************************************************************************/
989
990wchar_t* CDECL OS2wcschr(const wchar_t* str,
991 int i)
992{
993 dprintf(("NTDLL: wcschr(%08xh,%08xh)\n",
994 str,
995 i));
996
997 return (wcschr(str, i));
998}
999
1000
1001/*****************************************************************************
1002 * Name :
1003 * Purpose :
1004 * Parameters:
1005 * Variables :
1006 * Result :
1007 * Remark : NTDLL.936
1008 * Status :
1009 *
1010 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1011 *****************************************************************************/
1012
1013int CDECL OS2wcscmp(const wchar_t* str1,
1014 const wchar_t* str2)
1015{
1016 dprintf(("NTDLL: wcscmp(%08xh,%08xh)\n",
1017 str1,
1018 str2));
1019
1020 return (wcscmp(str1, str2));
1021}
1022
1023
1024/*****************************************************************************
1025 * Name :
1026 * Purpose :
1027 * Parameters:
1028 * Variables :
1029 * Result :
1030 * Remark : NTDLL.937
1031 * Status :
1032 *
1033 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1034 *****************************************************************************/
1035
1036wchar_t* CDECL OS2wcscpy( wchar_t* str1,
1037 const wchar_t* str2)
1038{
1039 dprintf(("NTDLL: wcscpy(%08xh,%08xh)\n",
1040 str1,
1041 str2));
1042
1043 return (wcscpy(str1, str2));
1044}
1045
1046
1047/*****************************************************************************
1048 * Name :
1049 * Purpose :
1050 * Parameters:
1051 * Variables :
1052 * Result :
1053 * Remark : NTDLL.938
1054 * Status :
1055 *
1056 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1057 *****************************************************************************/
1058
1059size_t CDECL OS2wcscspn(const wchar_t* str1,
1060 wchar_t* str2)
1061{
1062 dprintf(("NTDLL: wcscspn(%08xh,%08xh)\n",
1063 str1,
1064 str2));
1065
1066 return (wcscspn(str1, str2));
1067}
1068
1069
1070/*****************************************************************************
1071 * Name :
1072 * Purpose :
1073 * Parameters:
1074 * Variables :
1075 * Result :
1076 * Remark : NTDLL.939
1077 * Status :
1078 *
1079 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1080 *****************************************************************************/
1081
1082size_t CDECL OS2wcslen(const wchar_t* str)
1083{
1084 dprintf(("NTDLL: wcslen(%08xh)\n",
1085 str));
1086
1087 return (wcslen(str));
1088}
1089
1090
1091/*****************************************************************************
1092 * Name :
1093 * Purpose :
1094 * Parameters:
1095 * Variables :
1096 * Result :
1097 * Remark : NTDLL.940
1098 * Status :
1099 *
1100 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1101 *****************************************************************************/
1102
1103wchar_t* CDECL OS2wcsncat( wchar_t* str1,
1104 const wchar_t* str2,
1105 size_t i)
1106{
1107 dprintf(("NTDLL: wcsncat(%08xh,%08xh,%08xh)\n",
1108 str1,
1109 str2,
1110 i));
1111
1112 return (wcsncat(str1, str2, i));
1113}
1114
1115
1116/*****************************************************************************
1117 * Name :
1118 * Purpose :
1119 * Parameters:
1120 * Variables :
1121 * Result :
1122 * Remark : NTDLL.941
1123 * Status :
1124 *
1125 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1126 *****************************************************************************/
1127
1128int CDECL OS2wcsncmp(const wchar_t* str1,
1129 const wchar_t* str2,
1130 size_t i)
1131{
1132 dprintf(("NTDLL: wcsncmp(%08xh,%08xh,%08xh)\n",
1133 str1,
1134 str2,
1135 i));
1136
1137 return (wcsncmp(str1, str2, i));
1138}
1139
1140
1141/*****************************************************************************
1142 * Name :
1143 * Purpose :
1144 * Parameters:
1145 * Variables :
1146 * Result :
1147 * Remark : NTDLL.942
1148 * Status :
1149 *
1150 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1151 *****************************************************************************/
1152
1153wchar_t* CDECL OS2wcsncpy( wchar_t* str1,
1154 const wchar_t* str2,
1155 size_t i)
1156{
1157 dprintf(("NTDLL: wcsncpy(%s,%s,%08xh)\n",
1158 str1,
1159 str2,
1160 i));
1161
1162 return (wcsncpy(str1, str2, i));
1163}
1164
1165
1166/*****************************************************************************
1167 * Name :
1168 * Purpose :
1169 * Parameters:
1170 * Variables :
1171 * Result :
1172 * Remark : NTDLL.943
1173 * Status :
1174 *
1175 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1176 *****************************************************************************/
1177
1178wchar_t* CDECL OS2wcspbrk(const wchar_t* str1,
1179 const wchar_t* str2)
1180{
1181 dprintf(("NTDLL: wcspbrk(%08xh,%08xh)\n",
1182 str1,
1183 str2));
1184
1185 return (wcspbrk(str1, str2));
1186}
1187
1188
1189/*****************************************************************************
1190 * Name :
1191 * Purpose :
1192 * Parameters:
1193 * Variables :
1194 * Result :
1195 * Remark : NTDLL.944
1196 * Status :
1197 *
1198 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1199 *****************************************************************************/
1200
1201wchar_t* CDECL OS2wcsrchr(const wchar_t* str,
1202 size_t i)
1203{
1204 dprintf(("NTDLL: wcsrchr(%08xh,%08xh)\n",
1205 str,
1206 i));
1207
1208 return (wcsrchr(str, i));
1209}
1210
1211
1212/*****************************************************************************
1213 * Name :
1214 * Purpose :
1215 * Parameters:
1216 * Variables :
1217 * Result :
1218 * Remark : NTDLL.945
1219 * Status :
1220 *
1221 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1222 *****************************************************************************/
1223
1224size_t CDECL OS2wcsspn(const wchar_t* str1,
1225 const wchar_t* str2)
1226{
1227 dprintf(("NTDLL: wcsspn(%08xh,%08xh)\n",
1228 str1,
1229 str2));
1230
1231 return (wcsspn(str1, str2));
1232}
1233
1234
1235/*****************************************************************************
1236 * Name :
1237 * Purpose :
1238 * Parameters:
1239 * Variables :
1240 * Result :
1241 * Remark : NTDLL.946
1242 * Status :
1243 *
1244 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1245 *****************************************************************************/
1246
1247wchar_t* CDECL OS2wcsstr(const wchar_t* str1,
1248 const wchar_t* str2)
1249{
1250 dprintf(("NTDLL: wcsstr(%s,%s)\n",
1251 str1,
1252 str2));
1253
1254 return (wcsstr(str1, str2));
1255}
1256
1257
1258/*****************************************************************************
1259 * Name :
1260 * Purpose :
1261 * Parameters:
1262 * Variables :
1263 * Result :
1264 * Remark : NTDLL.?
1265 * Status :
1266 *
1267 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1268 *****************************************************************************/
1269
1270char * CDECL OS2_itoa(int i, char *s, int r)
1271{
1272 dprintf(("NTDLL: _itoa(%08xh, %08xh, %08xh)\n",
1273 i,
1274 s,
1275 r));
1276
1277 return (_itoa(i,s,r));
1278}
1279
1280
1281/*****************************************************************************
1282 * Name :
1283 * Purpose :
1284 * Parameters:
1285 * Variables :
1286 * Result :
1287 * Remark : NTDLL.?
1288 * Status :
1289 *
1290 * Author : Patrick Haller [Thu, 1999/06/22 20:44]
1291 *****************************************************************************/
1292
1293char * CDECL OS2_itow(int i, char *s, int r)
1294{
1295 dprintf(("NTDLL: _itow(%08xh, %08xh, %08xh) no unicode support !\n",
1296 i,
1297 s,
1298 r));
1299
1300 return (_itoa(i,s,r));
1301}
1302
1303
1304/*****************************************************************************
1305 * Name :
1306 * Purpose :
1307 * Parameters:
1308 * Variables :
1309 * Result :
1310 * Remark : NTDLL.749
1311 * Status :
1312 *
1313 * Author : Jens Wiessner
1314 *****************************************************************************/
1315
1316LONG CDECL NTDLL__CIpow(void)
1317{
1318 dprintf(("NTDLL: _CIpow not implemented.\n"));
1319
1320 return 0;
1321}
1322
1323
1324/*****************************************************************************
1325 * Name :
1326 * Purpose :
1327 * Parameters:
1328 * Variables :
1329 * Result :
1330 * Remark : NTDLL.864
1331 * Status :
1332 *
1333 * Author : Jens Wiessner
1334 *****************************************************************************/
1335
1336LONG CDECL NTDLL__ftol(void)
1337{
1338 dprintf(("NTDLL: _ftol not implemented.\n"));
1339
1340 return 0;
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 dprintf(("NTDLL: _ltoa(%08xh, %08xh, %08xh) not implemented\n",
1359 x,
1360 buf,
1361 radix));
1362
1363 return 0;
1364}
1365
1366
1367/*****************************************************************************
1368 * Name :
1369 * Purpose :
1370 * Parameters:
1371 * Variables :
1372 * Result :
1373 * Remark : NTDLL.868
1374 * Status :
1375 *
1376 * Author : Jens Wiessner
1377 *****************************************************************************/
1378
1379INT CDECL NTDLL__memicmp(
1380 LPCSTR s1, /* [in] first string */
1381 LPCSTR s2, /* [in] second string */
1382 DWORD len /* [in] length to compare */ )
1383{
1384 dprintf(("NTDLL: memicmp(%08xh, %08xh, %08xh)\n",s1,s2,len));
1385 int i;
1386
1387 for (i=0;i<len;i++) {
1388 if (tolower(s1[i])<tolower(s2[i]))
1389 return -1;
1390 if (tolower(s1[i])>tolower(s2[i]))
1391 return 1;
1392 }
1393 return 0;
1394}
1395
1396
1397/*****************************************************************************
1398 * Name :
1399 * Purpose :
1400 * Parameters:
1401 * Variables :
1402 * Result :
1403 * Remark : NTDLL.869
1404 * Status :
1405 *
1406 * Author : Jens Wiessner
1407 *****************************************************************************/
1408
1409int CDECL NTDLL__snprintf( char *buf, size_t bufsize, const char *fmt, ... )
1410{
1411 dprintf(("NTDLL: _snprintf(%08xh, %08xh, %08xh) not implemented\n",
1412 buf,
1413 bufsize,
1414 fmt));
1415
1416 return 0;
1417}
1418
1419
1420/*****************************************************************************
1421 * Name :
1422 * Purpose :
1423 * Parameters:
1424 * Variables :
1425 * Result :
1426 * Remark : NTDLL.870
1427 * Status :
1428 *
1429 * Author : Jens Wiessner
1430 *****************************************************************************/
1431
1432int CDECL NTDLL__snwprintf( wchar_t *buf, size_t bufsize, const wchar_t *fmt, ... )
1433{
1434 dprintf(("NTDLL: _snwprintf(%08xh, %08xh, %08xh) not implemented\n",
1435 buf,
1436 bufsize,
1437 fmt));
1438
1439 return 0;
1440}
1441
1442
1443/*****************************************************************************
1444 * Name :
1445 * Purpose :
1446 * Parameters:
1447 * Variables :
1448 * Result :
1449 * Remark : NTDLL.871
1450 * Status :
1451 *
1452 * Author : Jens Wiessner
1453 *****************************************************************************/
1454
1455void CDECL NTDLL__splitpath( const char *path, char *drive,
1456 char *dir, char *fname, char *ext )
1457{
1458 dprintf(("NTDLL: _splitpath(%08xh, %08xh, %08xh, %08xh, %08xh) not implemented\n",
1459 path,
1460 drive,
1461 dir,
1462 fname,
1463 ext));
1464
1465}
1466
1467
1468/*****************************************************************************
1469 * Name :
1470 * Purpose :
1471 * Parameters:
1472 * Variables :
1473 * Result :
1474 * Remark : NTDLL.872
1475 * Status :
1476 *
1477 * Author : Jens Wiessner
1478 *****************************************************************************/
1479
1480void CDECL NTDLL__strcmpi( LPCSTR s1, LPCSTR s2 )
1481{
1482 dprintf(("NTDLL: _strcmpi(%08xh, %08xh)\n",
1483 s1,
1484 s2));
1485
1486 lstrcmpiA( s1, s2 );
1487}
1488
1489
1490/*****************************************************************************
1491 * Name :
1492 * Purpose :
1493 * Parameters:
1494 * Variables :
1495 * Result :
1496 * Remark : NTDLL.874
1497 * Status :
1498 *
1499 * Author : Jens Wiessner
1500 *****************************************************************************/
1501
1502CHAR * CDECL NTDLL__strlwr(char *x)
1503{
1504 char *y =x;
1505
1506 dprintf(("NTDLL: _strlwr got %s\n", x));
1507 while (*y) {
1508 if ((*y > 0x40) && (*y< 0x5b))
1509 *y = *y + 0x20;
1510 y++;
1511 }
1512 dprintf((" returned %s\n", x));
1513
1514 return x;
1515}
1516
1517
1518/*****************************************************************************
1519 * Name :
1520 * Purpose :
1521 * Parameters:
1522 * Variables :
1523 * Result :
1524 * Remark : NTDLL.875
1525 * Status :
1526 *
1527 * Author : Jens Wiessner
1528 *****************************************************************************/
1529
1530int CDECL NTDLL__strnicmp( LPCSTR s1, LPCSTR s2, INT n )
1531{
1532 dprintf(("NTDLL: _strnicmp(%08xh, %08xh, %08xh) not implemented\n",
1533 s1,
1534 s2,
1535 n));
1536
1537 return 0;
1538}
1539
1540
1541/*****************************************************************************
1542 * Name :
1543 * Purpose :
1544 * Parameters:
1545 * Variables :
1546 * Result :
1547 * Remark : NTDLL.876
1548 * Status :
1549 *
1550 * Author : Jens Wiessner
1551 *****************************************************************************/
1552
1553LPSTR CDECL NTDLL__strupr(LPSTR x)
1554{
1555 dprintf(("NTDLL: _strupr(%08xh)\n",
1556 x));
1557
1558 LPSTR y=x;
1559
1560 while (*y) {
1561 *y=toupper(*y);
1562 y++;
1563 }
1564 return x;
1565}
1566
1567
1568/*****************************************************************************
1569 * Name :
1570 * Purpose :
1571 * Parameters:
1572 * Variables :
1573 * Result :
1574 * Remark : NTDLL.877
1575 * Status :
1576 *
1577 * Author : Jens Wiessner
1578 *****************************************************************************/
1579
1580LPSTR CDECL NTDLL__ultoa(long x,LPSTR buf,INT radix)
1581{
1582 dprintf(("NTDLL: _ultoa(%08xh, %08xh, %08xh) not implemented\n",
1583 x,
1584 buf,
1585 radix));
1586
1587 return 0;
1588}
1589
1590
1591/*****************************************************************************
1592 * Name :
1593 * Purpose :
1594 * Parameters:
1595 * Variables :
1596 * Result :
1597 * Remark : NTDLL.878
1598 * Status :
1599 *
1600 * Author : Jens Wiessner
1601 *****************************************************************************/
1602
1603int CDECL NTDLL__vsnprintf( char *s, size_t bufsize, const char *format, va_list arg )
1604{
1605 dprintf(("NTDLL: _ultoa(%08xh, %08xh, %08xh) not implemented\n",
1606 s,
1607 bufsize,
1608 format));
1609
1610 return 0;
1611}
1612
1613
1614/*****************************************************************************
1615 * Name :
1616 * Purpose :
1617 * Parameters:
1618 * Variables :
1619 * Result :
1620 * Remark : NTDLL.897
1621 * Status :
1622 *
1623 * Author : Jens Wiessner
1624 *****************************************************************************/
1625
1626int CDECL NTDLL_iswalpha(wint_t i)
1627{
1628 dprintf(("NTDLL: iswalpha(%08xh)\n", i));
1629
1630 return (iswalpha(i));
1631}
1632
1633
1634/*****************************************************************************
1635 * Name :
1636 * Purpose :
1637 * Parameters:
1638 * Variables :
1639 * Result :
1640 * Remark : NTDLL.898
1641 * Status :
1642 *
1643 * Author : Jens Wiessner
1644 *****************************************************************************/
1645
1646int CDECL NTDLL_iswctype(wint_t i, wctype_t wct)
1647{
1648 dprintf(("NTDLL: iswctype(%08xh, %08xh)\n", i, wct));
1649
1650 return (iswctype(i, wct));
1651}
1652
1653
1654/*****************************************************************************
1655 * Name :
1656 * Purpose :
1657 * Parameters:
1658 * Variables :
1659 * Result :
1660 * Remark : NTDLL.899
1661 * Status :
1662 *
1663 * Author : Jens Wiessner
1664 *****************************************************************************/
1665
1666int CDECL NTDLL_isxdigit(int i)
1667{
1668 dprintf(("NTDLL: isxdigit(%08xh)\n", i));
1669
1670 return (isxdigit(i));
1671}
1672
1673
1674/*****************************************************************************
1675 * Name :
1676 * Purpose :
1677 * Parameters:
1678 * Variables :
1679 * Result :
1680 * Remark : NTDLL.900
1681 * Status :
1682 *
1683 * Author : Jens Wiessner
1684 *****************************************************************************/
1685
1686long int CDECL NTDLL_labs( long int j )
1687{
1688 dprintf(("NTDLL: labs(%08xh)\n", j));
1689
1690 return (labs(j));
1691}
1692
1693
1694/*****************************************************************************
1695 * Name :
1696 * Purpose :
1697 * Parameters:
1698 * Variables :
1699 * Result :
1700 * Remark : NTDLL.901
1701 * Status :
1702 *
1703 * Author : Jens Wiessner
1704 *****************************************************************************/
1705
1706double CDECL NTDLL_log( double x )
1707{
1708 dprintf(("NTDLL: log(%08xh)\n", x));
1709 return (log(x));
1710}
1711
1712
1713/*****************************************************************************
1714 * Name :
1715 * Purpose :
1716 * Parameters:
1717 * Variables :
1718 * Result :
1719 * Remark : NTDLL.902
1720 * Status :
1721 *
1722 * Author : Jens Wiessner
1723 *****************************************************************************/
1724
1725size_t CDECL NTDLL_mbstowcs( wchar_t *pwcs, const char *s, size_t n )
1726{
1727 dprintf(("NTDLL: mbstowcs(%08xh, %08xh, %08xh)\n", pwcs, s, n));
1728 return (mbstowcs(pwcs, s, n));
1729}
1730
1731
1732/*****************************************************************************
1733 * Name :
1734 * Purpose :
1735 * Parameters:
1736 * Variables :
1737 * Result :
1738 * Remark : NTDLL.903
1739 * Status :
1740 *
1741 * Author : Jens Wiessner
1742 *****************************************************************************/
1743
1744void * CDECL NTDLL_memchr( const void *s, int c, size_t n )
1745{
1746 dprintf(("NTDLL: memchr(%08xh, %08xh, %08xh)\n", s, c, n));
1747 return memchr( s, c, n );
1748}
1749
1750
1751/*****************************************************************************
1752 * Name :
1753 * Purpose :
1754 * Parameters:
1755 * Variables :
1756 * Result :
1757 * Remark : NTDLL.904
1758 * Status :
1759 *
1760 * Author : Jens Wiessner
1761 *****************************************************************************/
1762
1763int CDECL NTDLL_memcmp( const void * c1, const void * c2, size_t n )
1764{
1765 dprintf(("NTDLL: memcmp(%08xh, %08xh, %08xh)\n", c1, c2, n));
1766 return memcmp( c1, c2, n );
1767}
1768
1769/*****************************************************************************
1770 * Name :
1771 * Purpose :
1772 * Parameters:
1773 * Variables :
1774 * Result :
1775 * Remark : NTDLL.905
1776 * Status :
1777 *
1778 * Author : Jens Wiessner
1779 *****************************************************************************/
1780
1781void * CDECL NTDLL_memcpy( void *s1, const void *s2, size_t n )
1782{
1783 dprintf(("NTDLL: memcpy(%08xh, %08xh, %08xh)\n", s1, s2, n));
1784 return memcpy( s1, s2, n );
1785}
1786
1787
1788/*****************************************************************************
1789 * Name :
1790 * Purpose :
1791 * Parameters:
1792 * Variables :
1793 * Result :
1794 * Remark : NTDLL.907
1795 * Status :
1796 *
1797 * Author : Jens Wiessner
1798 *****************************************************************************/
1799
1800void * CDECL NTDLL_memset( void *s, int i, size_t n )
1801{
1802 dprintf(("NTDLL: memset(%08xh, %08xh, %08xh)\n", s, i, n));
1803 return memset( s, i, n );
1804}
1805
1806
1807/*****************************************************************************
1808 * Name :
1809 * Purpose :
1810 * Parameters:
1811 * Variables :
1812 * Result :
1813 * Remark : NTDLL.908
1814 * Status :
1815 *
1816 * Author : Jens Wiessner
1817 *****************************************************************************/
1818
1819double CDECL NTDLL_pow( double x, double y )
1820{
1821 dprintf(("NTDLL: pow(%08xh, %08xh)\n",x, y));
1822 return pow( x, y );
1823}
1824
1825
1826/*****************************************************************************
1827 * Name :
1828 * Purpose :
1829 * Parameters:
1830 * Variables :
1831 * Result :
1832 * Remark : NTDLL.909
1833 * Status :
1834 *
1835 * Author : Jens Wiessner
1836 *****************************************************************************/
1837
1838void CDECL NTDLL_qsort( void *base, size_t nmemb, size_t size,
1839 int (*compar)( const void *s1, const void *s2 ))
1840{
1841 dprintf(("NTDLL: qsort(%08xh, %08xh, %08xh, %08xh)\n",
1842 base, nmemb, size, compar));
1843}
1844
1845
1846/*****************************************************************************
1847 * Name :
1848 * Purpose :
1849 * Parameters:
1850 * Variables :
1851 * Result :
1852 * Remark : NTDLL.910
1853 * Status :
1854 *
1855 * Author : Jens Wiessner
1856 *****************************************************************************/
1857
1858double CDECL NTDLL_sin( double x )
1859{
1860 dprintf(("NTDLL: sin(%08xh)\n", x));
1861 return (sin(x));
1862}
1863
1864
1865/*****************************************************************************
1866 * Name :
1867 * Purpose :
1868 * Parameters:
1869 * Variables :
1870 * Result :
1871 * Remark : NTDLL.912
1872 * Status :
1873 *
1874 * Author : Jens Wiessner
1875 *****************************************************************************/
1876
1877double CDECL NTDLL_sqrt( double x )
1878{
1879 dprintf(("NTDLL: sqrt(%08xh)\n", x));
1880 return (sqrt(x));
1881}
1882
1883
1884
1885/*****************************************************************************
1886 * Name :
1887 * Purpose :
1888 * Parameters:
1889 * Variables :
1890 * Result :
1891 * Remark : NTDLL.913
1892 * Status :
1893 *
1894 * Author : Jens Wiessner
1895 *****************************************************************************/
1896
1897int CDECL NTDLL_sscanf( const char *s, const char *format, ... )
1898{
1899 dprintf(("NTDLL: sscanf(%08xh, %08xh) not implemented.\n"));
1900 return 0;
1901}
1902
1903
1904/*****************************************************************************
1905 * Name :
1906 * Purpose :
1907 * Parameters:
1908 * Variables :
1909 * Result :
1910 * Remark : NTDLL.933
1911 * Status :
1912 *
1913 * Author : Jens Wiessner
1914 *****************************************************************************/
1915
1916int CDECL NTDLL_vsprintf( char *s, const char *format, va_list arg )
1917{
1918 dprintf(("NTDLL: vsprintf(%08xh, %08xh)\n", s, format));
1919 return (vsprintf(s, format, arg));
1920}
1921
1922
1923/*****************************************************************************
1924 * Name :
1925 * Purpose :
1926 * Parameters:
1927 * Variables :
1928 * Result :
1929 * Remark : NTDLL.947
1930 * Status :
1931 *
1932 * Author : Jens Wiessner
1933 *****************************************************************************/
1934
1935wchar_t * CDECL NTDLL_wcstok( wchar_t *s1, const wchar_t *s2, wchar_t **ptr )
1936{
1937 dprintf(("NTDLL: wcstok(%08xh, %08xh, %08xh)\n",s1,s2,ptr));
1938 return (wcstok(s1, s2, ptr));
1939}
1940
1941/*****************************************************************************
1942 * Name :
1943 * Purpose :
1944 * Parameters:
1945 * Variables :
1946 * Result :
1947 * Remark : NTDLL.948
1948 * Status :
1949 *
1950 * Author : Jens Wiessner
1951 *****************************************************************************/
1952
1953long int CDECL NTDLL_wcstol( const wchar_t *s1, wchar_t **s2, int i )
1954{
1955 dprintf(("NTDLL: wcstol(%08xh, %08xh, %08xh)\n",s1,s2,i));
1956 return (wcstol(s1, s2, i));
1957}
1958
1959
1960/*****************************************************************************
1961 * Name :
1962 * Purpose :
1963 * Parameters:
1964 * Variables :
1965 * Result :
1966 * Remark : NTDLL.949
1967 * Status :
1968 *
1969 * Author : Jens Wiessner
1970 *****************************************************************************/
1971
1972size_t CDECL NTDLL_wcstombs( char *s, const wchar_t *pwcs, size_t n )
1973{
1974 dprintf(("NTDLL: wcstombs(%08xh, %08xh, %08xh)\n",s,pwcs,n));
1975 return (wcstombs(s, pwcs, n));
1976}
1977
1978
1979/*****************************************************************************
1980 * Name :
1981 * Purpose :
1982 * Parameters:
1983 * Variables :
1984 * Result :
1985 * Remark : NTDLL.950
1986 * Status :
1987 *
1988 * Author : Jens Wiessner
1989 *****************************************************************************/
1990
1991unsigned long int CDECL NTDLL_wcstoul( const wchar_t *s1, wchar_t **s2, int i )
1992{
1993 dprintf(("NTDLL: wcstoul(%08xh, %08xh, %08xh)\n",s1,s2,i));
1994 return (wcstoul(s1, s2, i));
1995}
1996
1997
1998/*****************************************************************************
1999 * Name :
2000 * Purpose :
2001 * Parameters:
2002 * Variables :
2003 * Result :
2004 * Remark : NTDLL.983
2005 * Status :
2006 *
2007 * Author : Jens Wiessner
2008 *****************************************************************************/
2009
2010int CDECL NTDLL__wtoi( const wchar_t *s )
2011{
2012 dprintf(("NTDLL: _wtoi(%08xh) not implemented.\n"));
2013 return 0;
2014}
2015
2016
2017/*****************************************************************************
2018 * Name :
2019 * Purpose :
2020 * Parameters:
2021 * Variables :
2022 * Result :
2023 * Remark : NTDLL.984
2024 * Status :
2025 *
2026 * Author : Jens Wiessner
2027 *****************************************************************************/
2028
2029long int CDECL NTDLL__wtol( const wchar_t *s )
2030{
2031 dprintf(("NTDLL: _wtol(%08xh) not implemented.\n"));
2032 return 0;
2033}
Note: See TracBrowser for help on using the repository browser.