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

Last change on this file since 1948 was 1653, checked in by phaller, 26 years ago

Add: new functions implemented
File size: 45.5 KB
Line 
1/* $Id: crt.cpp,v 1.11 1999-11-09 09:30:20 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(double x, double y)
1317{
1318 dprintf(("NTDLL: _CIpow\n"));
1319 dprintf(("should be register function\n"));
1320 return pow(x, y);
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, char *dir, char *fname, char *ext )
1456{
1457 dprintf(("NTDLL: _splitpath"));
1458
1459 char *tmp_drive;
1460 char *tmp_dir;
1461 char *tmp_ext;
1462
1463 tmp_drive = (char *)strchr(path,':');
1464 if ( tmp_drive != (char *)NULL ) {
1465 strncpy(drive,tmp_drive-1,1);
1466 *(drive+1) = 0;
1467 }
1468 else {
1469 *drive = 0;
1470 tmp_drive = (char *)path;
1471 }
1472
1473 tmp_dir = (char *)strrchr(path,'\\');
1474 if( tmp_dir != NULL && tmp_dir != tmp_drive + 1 ) {
1475 strncpy(dir,tmp_drive+1,tmp_dir - tmp_drive);
1476 *(dir + (tmp_dir - tmp_drive)) = 0;
1477 }
1478 else
1479 *dir =0;
1480
1481 tmp_ext = ( char *)strrchr(path,'.');
1482 if ( tmp_ext != NULL ) {
1483 strcpy(ext,tmp_ext);
1484 }
1485 else
1486 *ext = 0;
1487 if ( tmp_dir != NULL ) {
1488 strncpy(fname,tmp_dir+1,tmp_ext - tmp_dir - 1);
1489 *(fname + (tmp_ext - tmp_dir -1)) = 0;
1490 }
1491 else
1492 strncpy(fname,path,tmp_ext - path);
1493
1494}
1495
1496
1497/*****************************************************************************
1498 * Name :
1499 * Purpose :
1500 * Parameters:
1501 * Variables :
1502 * Result :
1503 * Remark : NTDLL.872
1504 * Status :
1505 *
1506 * Author : Jens Wiessner
1507 *****************************************************************************/
1508
1509void CDECL NTDLL__strcmpi( LPCSTR s1, LPCSTR s2 )
1510{
1511 dprintf(("NTDLL: _strcmpi(%08xh, %08xh)\n",
1512 s1,
1513 s2));
1514
1515 lstrcmpiA( s1, s2 );
1516}
1517
1518
1519/*****************************************************************************
1520 * Name :
1521 * Purpose :
1522 * Parameters:
1523 * Variables :
1524 * Result :
1525 * Remark : NTDLL.874
1526 * Status :
1527 *
1528 * Author : Jens Wiessner
1529 *****************************************************************************/
1530
1531CHAR * CDECL NTDLL__strlwr(char *x)
1532{
1533 char *y =x;
1534
1535 dprintf(("NTDLL: _strlwr got %s\n", x));
1536 while (*y) {
1537 if ((*y > 0x40) && (*y< 0x5b))
1538 *y = *y + 0x20;
1539 y++;
1540 }
1541 dprintf((" returned %s\n", x));
1542
1543 return x;
1544}
1545
1546
1547/*****************************************************************************
1548 * Name :
1549 * Purpose :
1550 * Parameters:
1551 * Variables :
1552 * Result :
1553 * Remark : NTDLL.875
1554 * Status :
1555 *
1556 * Author : Jens Wiessner
1557 *****************************************************************************/
1558
1559int CDECL NTDLL__strnicmp( LPCSTR s1, LPCSTR s2, INT n )
1560{
1561 dprintf(("NTDLL: _strnicmp (%s,%s,%d)\n",
1562 s1,
1563 s2,
1564 n));
1565
1566 // @@@PH: sure it's not a UNICODE API?
1567 return (lstrncmpiA(s1,s2,n));
1568
1569/*
1570 if (n == 0)
1571 return 0;
1572 do {
1573 if (toupper(*s1) != toupper(*s2++))
1574 return toupper(*(unsigned const char *)s1) - toupper(*(unsigned const char *)--s2);
1575 if (*s1++ == 0)
1576 break;
1577 } while (--n != 0);
1578 return 0;
1579*/
1580}
1581
1582
1583/*****************************************************************************
1584 * Name :
1585 * Purpose :
1586 * Parameters:
1587 * Variables :
1588 * Result :
1589 * Remark : NTDLL.876
1590 * Status :
1591 *
1592 * Author : Jens Wiessner
1593 *****************************************************************************/
1594
1595LPSTR CDECL NTDLL__strupr(LPSTR x)
1596{
1597 dprintf(("NTDLL: _strupr(%s)\n",
1598 x));
1599
1600 LPSTR y=x;
1601
1602 while (*y)
1603 {
1604 *y=toupper(*y);
1605 y++;
1606 }
1607 return x;
1608}
1609
1610
1611/*****************************************************************************
1612 * Name :
1613 * Purpose :
1614 * Parameters:
1615 * Variables :
1616 * Result :
1617 * Remark : NTDLL.877
1618 * Status :
1619 *
1620 * Author : Jens Wiessner
1621 *****************************************************************************/
1622
1623LPSTR CDECL NTDLL__ultoa(long x,LPSTR buf,INT radix)
1624{
1625 dprintf(("NTDLL: _ultoa(%08xh, %08xh, %08xh) not implemented\n",
1626 x,
1627 buf,
1628 radix));
1629
1630 return 0;
1631}
1632
1633
1634/*****************************************************************************
1635 * Name :
1636 * Purpose :
1637 * Parameters:
1638 * Variables :
1639 * Result :
1640 * Remark : NTDLL.878
1641 * Status :
1642 *
1643 * Author : Jens Wiessner
1644 *****************************************************************************/
1645
1646int CDECL NTDLL__vsnprintf( char *s, size_t bufsize, const char *format, va_list arg )
1647{
1648 dprintf(("NTDLL: _ultoa(%08xh, %08xh, %08xh)\n",
1649 s,
1650 bufsize,
1651 format));
1652
1653 return wvsnprintfA(s, bufsize, format, arg);
1654}
1655
1656
1657/*****************************************************************************
1658 * Name :
1659 * Purpose :
1660 * Parameters:
1661 * Variables :
1662 * Result :
1663 * Remark : NTDLL.897
1664 * Status :
1665 *
1666 * Author : Jens Wiessner
1667 *****************************************************************************/
1668
1669int CDECL NTDLL_iswalpha(wint_t i)
1670{
1671 dprintf(("NTDLL: iswalpha(%08xh)\n", i));
1672
1673 return (iswalpha(i));
1674}
1675
1676
1677/*****************************************************************************
1678 * Name :
1679 * Purpose :
1680 * Parameters:
1681 * Variables :
1682 * Result :
1683 * Remark : NTDLL.898
1684 * Status :
1685 *
1686 * Author : Jens Wiessner
1687 *****************************************************************************/
1688
1689int CDECL NTDLL_iswctype(wint_t i, wctype_t wct)
1690{
1691 dprintf(("NTDLL: iswctype(%08xh, %08xh)\n", i, wct));
1692
1693 return (iswctype(i, wct));
1694}
1695
1696
1697/*****************************************************************************
1698 * Name :
1699 * Purpose :
1700 * Parameters:
1701 * Variables :
1702 * Result :
1703 * Remark : NTDLL.899
1704 * Status :
1705 *
1706 * Author : Jens Wiessner
1707 *****************************************************************************/
1708
1709int CDECL NTDLL_isxdigit(int i)
1710{
1711 dprintf(("NTDLL: isxdigit(%08xh)\n", i));
1712
1713 return (isxdigit(i));
1714}
1715
1716
1717/*****************************************************************************
1718 * Name :
1719 * Purpose :
1720 * Parameters:
1721 * Variables :
1722 * Result :
1723 * Remark : NTDLL.900
1724 * Status :
1725 *
1726 * Author : Jens Wiessner
1727 *****************************************************************************/
1728
1729long int CDECL NTDLL_labs( long int j )
1730{
1731 dprintf(("NTDLL: labs(%08xh)\n", j));
1732
1733 return (labs(j));
1734}
1735
1736
1737/*****************************************************************************
1738 * Name :
1739 * Purpose :
1740 * Parameters:
1741 * Variables :
1742 * Result :
1743 * Remark : NTDLL.901
1744 * Status :
1745 *
1746 * Author : Jens Wiessner
1747 *****************************************************************************/
1748
1749double CDECL NTDLL_log( double x )
1750{
1751 dprintf(("NTDLL: log(%08xh)\n", x));
1752 return (log(x));
1753}
1754
1755
1756/*****************************************************************************
1757 * Name :
1758 * Purpose :
1759 * Parameters:
1760 * Variables :
1761 * Result :
1762 * Remark : NTDLL.902
1763 * Status :
1764 *
1765 * Author : Jens Wiessner
1766 *****************************************************************************/
1767
1768size_t CDECL NTDLL_mbstowcs( wchar_t *pwcs, const char *s, size_t n )
1769{
1770 dprintf(("NTDLL: mbstowcs(%08xh, %08xh, %08xh)\n", pwcs, s, n));
1771 return (mbstowcs(pwcs, s, n));
1772}
1773
1774
1775/*****************************************************************************
1776 * Name :
1777 * Purpose :
1778 * Parameters:
1779 * Variables :
1780 * Result :
1781 * Remark : NTDLL.903
1782 * Status :
1783 *
1784 * Author : Jens Wiessner
1785 *****************************************************************************/
1786
1787void * CDECL NTDLL_memchr( const void *s, int c, size_t n )
1788{
1789 dprintf(("NTDLL: memchr(%08xh, %08xh, %08xh)\n", s, c, n));
1790 return memchr( s, c, n );
1791}
1792
1793
1794/*****************************************************************************
1795 * Name :
1796 * Purpose :
1797 * Parameters:
1798 * Variables :
1799 * Result :
1800 * Remark : NTDLL.904
1801 * Status :
1802 *
1803 * Author : Jens Wiessner
1804 *****************************************************************************/
1805
1806int CDECL NTDLL_memcmp( const void * c1, const void * c2, size_t n )
1807{
1808 dprintf(("NTDLL: memcmp(%08xh, %08xh, %08xh)\n", c1, c2, n));
1809 return memcmp( c1, c2, n );
1810}
1811
1812/*****************************************************************************
1813 * Name :
1814 * Purpose :
1815 * Parameters:
1816 * Variables :
1817 * Result :
1818 * Remark : NTDLL.905
1819 * Status :
1820 *
1821 * Author : Jens Wiessner
1822 *****************************************************************************/
1823
1824void * CDECL NTDLL_memcpy( void *s1, const void *s2, size_t n )
1825{
1826 dprintf(("NTDLL: memcpy(%08xh, %08xh, %08xh)\n", s1, s2, n));
1827 return memcpy( s1, s2, n );
1828}
1829
1830
1831/*****************************************************************************
1832 * Name :
1833 * Purpose :
1834 * Parameters:
1835 * Variables :
1836 * Result :
1837 * Remark : NTDLL.907
1838 * Status :
1839 *
1840 * Author : Jens Wiessner
1841 *****************************************************************************/
1842
1843void * CDECL NTDLL_memset( void *s, int i, size_t n )
1844{
1845 dprintf(("NTDLL: memset(%08xh, %08xh, %08xh)\n", s, i, n));
1846 return memset( s, i, n );
1847}
1848
1849
1850/*****************************************************************************
1851 * Name :
1852 * Purpose :
1853 * Parameters:
1854 * Variables :
1855 * Result :
1856 * Remark : NTDLL.908
1857 * Status :
1858 *
1859 * Author : Jens Wiessner
1860 *****************************************************************************/
1861
1862double CDECL NTDLL_pow( double x, double y )
1863{
1864 dprintf(("NTDLL: pow(%08xh, %08xh)\n",x, y));
1865 return pow( x, y );
1866}
1867
1868
1869/*****************************************************************************
1870 * Name :
1871 * Purpose :
1872 * Parameters:
1873 * Variables :
1874 * Result :
1875 * Remark : NTDLL.909
1876 * Status :
1877 *
1878 * Author : Jens Wiessner
1879 *****************************************************************************/
1880
1881void CDECL NTDLL_qsort( void *base, size_t nmemb, size_t size,
1882 int (*compar)( const void *s1, const void *s2 ))
1883{
1884 dprintf(("NTDLL: qsort(%08xh, %08xh, %08xh, %08xh) not implemented.\n",
1885 base, nmemb, size, compar));
1886}
1887
1888
1889/*****************************************************************************
1890 * Name :
1891 * Purpose :
1892 * Parameters:
1893 * Variables :
1894 * Result :
1895 * Remark : NTDLL.910
1896 * Status :
1897 *
1898 * Author : Jens Wiessner
1899 *****************************************************************************/
1900
1901double CDECL NTDLL_sin( double x )
1902{
1903 dprintf(("NTDLL: sin(%08xh)\n", x));
1904 return (sin(x));
1905}
1906
1907
1908/*****************************************************************************
1909 * Name :
1910 * Purpose :
1911 * Parameters:
1912 * Variables :
1913 * Result :
1914 * Remark : NTDLL.912
1915 * Status :
1916 *
1917 * Author : Jens Wiessner
1918 *****************************************************************************/
1919
1920double CDECL NTDLL_sqrt( double x )
1921{
1922 dprintf(("NTDLL: sqrt(%08xh)\n", x));
1923 return (sqrt(x));
1924}
1925
1926
1927
1928/*****************************************************************************
1929 * Name :
1930 * Purpose :
1931 * Parameters:
1932 * Variables :
1933 * Result :
1934 * Remark : NTDLL.913
1935 * Status :
1936 *
1937 * Author : Jens Wiessner
1938 *****************************************************************************/
1939
1940int CDECL NTDLL_sscanf( const char *s, const char *format, ... )
1941{
1942 dprintf(("NTDLL: sscanf(%08xh, %08xh) not implemented.\n"));
1943 return 0;
1944}
1945
1946
1947/*****************************************************************************
1948 * Name :
1949 * Purpose :
1950 * Parameters:
1951 * Variables :
1952 * Result :
1953 * Remark : NTDLL.933
1954 * Status :
1955 *
1956 * Author : Jens Wiessner
1957 *****************************************************************************/
1958
1959int CDECL NTDLL_vsprintf( char *s, const char *format, va_list arg )
1960{
1961 dprintf(("NTDLL: vsprintf(%08xh, %08xh)\n", s, format));
1962 return (vsprintf(s, format, arg));
1963}
1964
1965
1966/*****************************************************************************
1967 * Name :
1968 * Purpose :
1969 * Parameters:
1970 * Variables :
1971 * Result :
1972 * Remark : NTDLL.947
1973 * Status :
1974 *
1975 * Author : Jens Wiessner
1976 *****************************************************************************/
1977
1978wchar_t * CDECL NTDLL_wcstok( wchar_t *s1, const wchar_t *s2, wchar_t **ptr )
1979{
1980 dprintf(("NTDLL: wcstok(%08xh, %08xh, %08xh)\n",s1,s2,ptr));
1981 return (wcstok(s1, s2, ptr));
1982}
1983
1984/*****************************************************************************
1985 * Name :
1986 * Purpose :
1987 * Parameters:
1988 * Variables :
1989 * Result :
1990 * Remark : NTDLL.948
1991 * Status :
1992 *
1993 * Author : Jens Wiessner
1994 *****************************************************************************/
1995
1996long int CDECL NTDLL_wcstol( const wchar_t *s1, wchar_t **s2, int i )
1997{
1998 dprintf(("NTDLL: wcstol(%08xh, %08xh, %08xh)\n",s1,s2,i));
1999 return (wcstol(s1, s2, i));
2000}
2001
2002
2003/*****************************************************************************
2004 * Name :
2005 * Purpose :
2006 * Parameters:
2007 * Variables :
2008 * Result :
2009 * Remark : NTDLL.949
2010 * Status :
2011 *
2012 * Author : Jens Wiessner
2013 *****************************************************************************/
2014
2015size_t CDECL NTDLL_wcstombs( char *s, const wchar_t *pwcs, size_t n )
2016{
2017 dprintf(("NTDLL: wcstombs(%08xh, %08xh, %08xh)\n",s,pwcs,n));
2018 return (wcstombs(s, pwcs, n));
2019}
2020
2021
2022/*****************************************************************************
2023 * Name :
2024 * Purpose :
2025 * Parameters:
2026 * Variables :
2027 * Result :
2028 * Remark : NTDLL.950
2029 * Status :
2030 *
2031 * Author : Jens Wiessner
2032 *****************************************************************************/
2033
2034unsigned long int CDECL NTDLL_wcstoul( const wchar_t *s1, wchar_t **s2, int i )
2035{
2036 dprintf(("NTDLL: wcstoul(%08xh, %08xh, %08xh)\n",s1,s2,i));
2037 return (wcstoul(s1, s2, i));
2038}
2039
2040
2041/*****************************************************************************
2042 * Name :
2043 * Purpose :
2044 * Parameters:
2045 * Variables :
2046 * Result :
2047 * Remark : NTDLL.983
2048 * Status :
2049 *
2050 * Author : Jens Wiessner
2051 *****************************************************************************/
2052
2053int CDECL NTDLL__wtoi( const wchar_t *s )
2054{
2055 dprintf(("NTDLL: _wtoi(%08xh) not implemented.\n"));
2056 return 0;
2057}
2058
2059
2060/*****************************************************************************
2061 * Name :
2062 * Purpose :
2063 * Parameters:
2064 * Variables :
2065 * Result :
2066 * Remark : NTDLL.984
2067 * Status :
2068 *
2069 * Author : Jens Wiessner
2070 *****************************************************************************/
2071
2072long int CDECL NTDLL__wtol( const wchar_t *s )
2073{
2074 dprintf(("NTDLL: _wtol(%08xh) not implemented.\n"));
2075 return 0;
2076}
Note: See TracBrowser for help on using the repository browser.