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

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

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