source: trunk/src/crtdll/crt_wc.cpp@ 4803

Last change on this file since 4803 was 4667, checked in by phaller, 25 years ago

Major move towards WINE CRTDLL, mixture between both code branches
File size: 17.2 KB
Line 
1/* $Id: crt_wc.cpp,v 1.3 2000-11-21 23:48:49 phaller Exp $ */
2
3/*
4 * The C RunTime DLL
5 *
6 * Implements C run-time functionality as known from UNIX.
7 *
8 * Partialy based on Wine
9 *
10 * Copyright 1996,1998 Marcus Meissner
11 * Copyright 1996 Jukka Iivonen
12 * Copyright 1997 Uwe Bonnes
13 * Copyright 1999-2000 Jens Wiessner
14 * Copyright 2000 Przemyslaw Dobrowolski
15 *
16 * CRTDLL - widechar functions
17 *
18 */
19
20#include <odin.h>
21#include <os2win.h>
22#include <wchar.h>
23#include <wctype.h>
24#include <heapstring.h>
25#include <string.h>
26#include "crtimps.h"
27
28
29/*********************************************************************
30 * _fgetwchar (CRTDLL.93)
31 */
32wint_t CDECL CRTDLL__fgetwchar( void *i )
33{
34 // TODO: Check if really ok.
35 dprintf2(("CRTDLL: _fgetwchar -> _getch\n"));
36 return CRTDLL__getch();
37}
38
39
40/*********************************************************************
41 * CRTDLL__wcsdup (CRTDLL.317)
42 */
43LPWSTR CDECL CRTDLL__wcsdup( LPCWSTR str )
44{
45 dprintf2(("CRTDLL: _wcsdup\n"));
46 LPWSTR ret = NULL;
47 if (str)
48 {
49 int size = (wcslen((const wchar_t*)str) + 1) * sizeof(WCHAR);
50 ret = (WCHAR*)CRTDLL_malloc( size );
51 if (ret) memcpy( ret, str, size );
52 }
53 return ret;
54}
55
56
57/*********************************************************************
58 * CRTDLL__wcsicmp (CRTDLL.318)
59 */
60int CDECL CRTDLL__wcsicmp(LPWSTR str1, LPWSTR str2)
61{
62 dprintf2(("CRTDLL: _wcsicmp(%08xh,%08xh)\n",
63 str1,
64 str2));
65
66 return (CRTDLL__wcsnicmp(str1,
67 str2,
68 wcslen((wchar_t*) str1)));
69}
70
71
72/*********************************************************************
73 * CRTDLL__wcsicoll (CRTDLL.319)
74 */
75int CDECL CRTDLL__wcsicoll( LPCWSTR str1, LPCWSTR str2 )
76{
77 dprintf2(("CRTDLL: _wcsicoll\n"));
78 return CRTDLL__wcsicmp( (LPWSTR)str1, (LPWSTR)str2 );
79}
80
81
82/*********************************************************************
83 * CRTDLL__wcslwr (CRTDLL.320)
84 */
85LPWSTR CDECL CRTDLL__wcslwr(LPWSTR str)
86{
87 DWORD dwIndex;
88
89 dprintf2(("CRTDLL: _wcslwr(%08xh)\n",
90 str));
91
92 for (dwIndex = wcslen((const wchar_t*)str);
93 dwIndex;
94 dwIndex--)
95 {
96 towlower(str[dwIndex]);
97 }
98
99 return (str);
100}
101
102
103/*********************************************************************
104 * CRTDLL__wcsnicmp (CRTDLL.321)
105 */
106int CDECL CRTDLL__wcsnicmp(LPCWSTR str1, LPCWSTR str2, int n)
107{
108 dprintf2(("CRTDLL: _wcsnicmp(%08xh,%08xh,%08xh)\n",
109 str1,
110 str2,
111 l));
112
113 if (!n) return 0;
114 while ((--n > 0) && *str1 && (towupper(*str1) == towupper(*str2)))
115 {
116 str1++;
117 str2++;
118 }
119 return towupper(*str1) - towupper(*str2);
120}
121
122
123/*********************************************************************
124 * CRTDLL__wcsnset (CRTDLL.322)
125 */
126LPWSTR CDECL CRTDLL__wcsnset( LPWSTR str, WCHAR c, INT n )
127{
128 dprintf2(("CRTDLL: _wcsnset\n"));
129 LPWSTR ret = str;
130 while ((n-- > 0) && *str) *str++ = c;
131 return ret;
132}
133
134
135/*********************************************************************
136 * CRTDLL__wcsrev (CRTDLL.323)
137 */
138LPWSTR CDECL CRTDLL__wcsrev( LPWSTR str )
139{
140 dprintf2(("CRTDLL: _wcsrev\n"));
141 LPWSTR ret = str;
142 LPWSTR end = str + wcslen((const wchar_t*)str) - 1;
143 while (end > str)
144 {
145 WCHAR t = *end;
146 *end-- = *str;
147 *str++ = t;
148 }
149 return ret;
150}
151
152
153/*********************************************************************
154 * CRTDLL__wcsset (CRTDLL.324)
155 */
156LPWSTR CDECL CRTDLL__wcsset( LPWSTR str, WCHAR c )
157{
158 dprintf2(("CRTDLL: _wcsset\n"));
159 LPWSTR ret = str;
160 while (*str) *str++ = c;
161 return ret;
162}
163
164
165/*********************************************************************
166 * CRTDLL__wcsupr (CRTDLL.325)
167 */
168LPWSTR CDECL CRTDLL__wcsupr(LPWSTR str)
169{
170 DWORD dwIndex;
171
172 dprintf2(("CRTDLL: _wcsupr(%08xh)\n",
173 str));
174
175 for (dwIndex = wcslen((const wchar_t*)str);
176 dwIndex;
177 dwIndex--)
178 {
179 towupper(str[dwIndex]);
180 }
181
182 return (str);
183}
184
185
186/*********************************************************************
187 * _wtoi (CRTDLL.330)
188 */
189int CDECL CRTDLL__wtoi( const wchar_t *s )
190{
191 // int -32768-32768 = size 6 + null-terminatedstr
192 char tempstr[7];
193
194 WideCharToMultiByte(0, // = CP_ACP
195 0,
196 (LPCWSTR)s,
197 -1,
198 tempstr,
199 7,
200 NULL,
201 NULL);
202
203 return (atoi(tempstr));
204}
205
206
207/*********************************************************************
208 * _wtol (CRTDLL.331)
209 */
210long int CDECL CRTDLL__wtol( const wchar_t *s )
211{
212 // long int -2147483647-2147483647 = size 10 + null-terminatedstr
213 char tempstr[11];
214 WideCharToMultiByte(0, // = CP_ACP
215 0,
216 (LPCWSTR)s,
217 -1,
218 tempstr,
219 11,
220 NULL,
221 NULL);
222
223 return (atol(tempstr));
224
225 return 0;
226}
227
228
229/*********************************************************************
230 * fgetwc (CRTDLL.366)
231 */
232wint_t CDECL CRTDLL_fgetwc( FILE *f )
233{
234 dprintf2(("CRTDLL: fgetwc\n"));
235 return (fgetwc(f));
236}
237
238
239/*********************************************************************
240 * fputwc (CRTDLL.373)
241 */
242wint_t CDECL CRTDLL_fputwc( wint_t wc, FILE *strm )
243{
244 dprintf2(("CRTDLL: fputwc\n"));
245 return (fputwc(wc, strm));
246}
247
248
249/*********************************************************************
250 * iswalnum (CRTDLL.402)
251 */
252int CDECL CRTDLL_iswalnum(wint_t i)
253{
254 dprintf2(("CRTDLL: iswalnum(%08xh)\n", i));
255 //return get_char_typeW(wc) & (C1_ALPHA|C1_DIGIT|C1_LOWER|C1_UPPER);
256 return (iswalnum(i));
257}
258
259
260/*********************************************************************
261 * iswalpha (CRTDLL.403)
262 */
263int CDECL CRTDLL_iswalpha(wint_t i)
264{
265 dprintf2(("CRTDLL: iswalpha(%08xh)\n", i));
266 return (iswalpha(i));
267 //return get_char_typeW(wc) & (C1_ALPHA|C1_LOWER|C1_UPPER);
268}
269
270
271/*********************************************************************
272 * iswcntrl (CRTDLL.405)
273 */
274int CDECL CRTDLL_iswcntrl(wint_t i)
275{
276 dprintf2(("CRTDLL: iswcntrl(%08xh)\n", i));
277 //return get_char_typeW(wc) & C1_CNTRL;
278 return (iswcntrl(i));
279}
280
281
282/*********************************************************************
283 * iswctype (CRTDLL.406)
284 */
285int CDECL CRTDLL_iswctype(wint_t i, wctype_t wct)
286{
287 dprintf2(("CRTDLL: iswctype(%08xh, %08xh)\n", i, wct));
288 return (iswctype(i, wct));
289}
290
291
292/*********************************************************************
293 * iswdigit (CRTDLL.407)
294 */
295int CDECL CRTDLL_iswdigit(wint_t i)
296{
297 dprintf2(("CRTDLL: iswdigit(%08xh)\n", i));
298 //return get_char_typeW(wc) & C1_DIGIT;
299 return (iswdigit(i));
300}
301
302
303/*********************************************************************
304 * iswgraph (CRTDLL.408)
305 */
306int CDECL CRTDLL_iswgraph(wint_t i)
307{
308 dprintf2(("CRTDLL: iswgraph(%08xh)\n", i));
309 //return get_char_typeW(wc) & (C1_ALPHA|C1_PUNCT|C1_DIGIT|C1_LOWER|C1_UPPER);
310 return (iswgraph(i));
311}
312
313
314/*********************************************************************
315 * iswlower (CRTDLL.409)
316 */
317int CDECL CRTDLL_iswlower(wint_t i)
318{
319 dprintf2(("CRTDLL: iswlower(%08xh)\n", i));
320 //return get_char_typeW(wc) & C1_LOWER;
321 return (iswlower(i));
322}
323
324
325/*********************************************************************
326 * iswprint (CRTDLL.410)
327 */
328int CDECL CRTDLL_iswprint(wint_t i)
329{
330 dprintf2(("CRTDLL: iswprint(%08xh)\n", i));
331 //return get_char_typeW(wc) & (C1_ALPHA|C1_BLANK|C1_PUNCT|C1_DIGIT|C1_LOWER|C1_UPPER);
332 return (iswprint(i));
333}
334
335
336/*********************************************************************
337 * iswpunct (CRTDLL.411)
338 */
339int CDECL CRTDLL_iswpunct(wint_t i)
340{
341 dprintf2(("CRTDLL: iswpunct(%08xh)\n", i));
342 //return get_char_typeW(wc) & C1_PUNCT;
343 return (iswpunct(i));
344}
345
346
347/*********************************************************************
348 * iswspace (CRTDLL.412)
349 */
350int CDECL CRTDLL_iswspace(wint_t i)
351{
352 dprintf2(("CRTDLL: iswspace(%08xh)\n", i));
353 //return get_char_typeW(wc) & C1_SPACE;
354 return (iswspace(i));
355}
356
357
358/*********************************************************************
359 * iswupper (CRTDLL.413)
360 */
361int CDECL CRTDLL_iswupper(wint_t i)
362{
363 dprintf2(("CRTDLL: iswupper(%08xh)\n", i));
364 //return get_char_typeW(wc) & C1_UPPER;
365 return (iswupper(i));
366}
367
368
369/*********************************************************************
370 * iswxdigit (CRTDLL.414)
371 */
372int CDECL CRTDLL_iswxdigit(wint_t i)
373{
374 dprintf2(("CRTDLL: iswxdigit(%08xh)\n", i));
375 //return get_char_typeW(wc) & C1_XDIGIT;
376 return (iswxdigit(i));
377}
378
379
380/*********************************************************************
381 * swprintf (CRTDLL.480)
382 */
383int CDECL CRTDLL_swprintf(const LPWSTR str,
384 int i,
385 const LPWSTR format,
386 ...)
387{
388 va_list valist;
389 int rc;
390
391 dprintf2(("CRTDLL: swprintf(%s,%d,%s)\n",
392 str,
393 i,
394 format));
395
396 va_start( valist, format );
397 rc = vswprintf( (wchar_t*)str,
398 i,
399 (wchar_t*)format,
400 valist );
401 va_end( valist );
402 return rc;
403}
404
405
406/*********************************************************************
407 * swscanf (CRTDLL.481)
408 */
409int CDECL CRTDLL_swscanf( const wchar_t *s1, const wchar_t *s2, va_list arg )
410{
411 dprintf(("CRTDLL: swscanf\n"));
412 return (swscanf(s1, s2, arg));
413}
414
415
416/*********************************************************************
417 * towlower (CRTDLL.490)
418 */
419WCHAR CDECL CRTDLL_towlower(WCHAR c)
420{
421 dprintf2(("CRTDLL: towlower(%c)\n",
422 c));
423
424 return (towlower(c));
425}
426
427
428/*********************************************************************
429 * towupper (CRTDLL.491)
430 */
431WCHAR CDECL CRTDLL_towupper(WCHAR c)
432{
433 dprintf2(("CRTDLL: towupper(%c)\n",
434 c));
435
436 return (towupper(c));
437}
438
439
440/*********************************************************************
441 * ungetwc (CRTDLL.493)
442 */
443wint_t CDECL CRTDLL_ungetwc( wint_t wc, FILE *strm )
444{
445 dprintf2(("CRTDLL: ungetwc\n"));
446 return (ungetwc(wc, strm));
447}
448
449
450/*********************************************************************
451 * wcscat (CRTDLL.500)
452 */
453wchar_t* CDECL CRTDLL_wcscat( wchar_t* str1,
454 const wchar_t* str2)
455{
456 dprintf2(("CRTDLL: wcscat(%08xh,%08xh)\n",
457 str1,
458 str2));
459
460 return (wcscat(str1, str2));
461}
462
463
464/*********************************************************************
465 * wcschr (CRTDLL.501)
466 */
467wchar_t* CDECL CRTDLL_wcschr(const wchar_t* str,
468 int i)
469{
470 dprintf2(("CRTDLL: wcschr(%08xh,%08xh)\n",
471 str,
472 i));
473
474 return (wcschr(str, i));
475}
476
477
478/*********************************************************************
479 * wcscmp (CRTDLL.502)
480 */
481int CDECL CRTDLL_wcscmp(const wchar_t* str1,
482 const wchar_t* str2)
483{
484 dprintf2(("CRTDLL: wcscmp(%08xh,%08xh)\n",
485 str1,
486 str2));
487
488 return (wcscmp(str1, str2));
489}
490
491
492/*********************************************************************
493 * wcscoll (CRTDLL.503)
494 */
495DWORD CDECL CRTDLL_wcscoll(LPCWSTR str1, LPCWSTR str2)
496{
497 dprintf2(("CRTDLL: wcscoll\n"));
498 return (wcscoll((const wchar_t*)str1, (const wchar_t*)str2));
499}
500
501
502/*********************************************************************
503 * wcscpy (CRTDLL.504)
504 */
505wchar_t* CDECL CRTDLL_wcscpy( wchar_t* str1,
506 const wchar_t* str2)
507{
508 dprintf2(("CRTDLL: wcscpy(%08xh,%08xh)\n",
509 str1,
510 str2));
511
512 return (wcscpy(str1, str2));
513}
514
515
516/*********************************************************************
517 * wcscspn (CRTDLL.505)
518 */
519size_t CDECL CRTDLL_wcscspn(const wchar_t* str1,
520 wchar_t* str2)
521{
522 dprintf2(("CRTDLL: wcscspn(%08xh,%08xh)\n",
523 str1,
524 str2));
525
526 return (wcscspn(str1, str2));
527}
528
529
530/*********************************************************************
531 * wcsftime (CRTDLL.506)
532 */
533size_t CDECL CRTDLL_wcsftime( wchar_t *s, size_t maxsize,
534 const wchar_t *format, const struct tm *timeptr )
535{
536 dprintf2(("CRTDLL: wcsftime\n"));
537 return (wcsftime(s, maxsize, format, timeptr));
538}
539
540
541/*********************************************************************
542 * wcslen (CRTDLL.507)
543 */
544size_t CDECL CRTDLL_wcslen(const wchar_t* str)
545{
546 dprintf2(("CRTDLL: wcslen(%08xh)\n",
547 str));
548
549 return (wcslen(str));
550}
551
552
553/*********************************************************************
554 * wcsncat (CRTDLL.508)
555 */
556wchar_t* CDECL CRTDLL_wcsncat( wchar_t* str1,
557 const wchar_t* str2,
558 size_t i)
559{
560 dprintf2(("CRTDLL: wcsncat(%08xh,%08xh,%08xh)\n",
561 str1,
562 str2,
563 i));
564
565 return (wcsncat(str1, str2, i));
566}
567
568
569
570/*********************************************************************
571 * wcsncmp (CRTDLL.509)
572 */
573int CDECL CRTDLL_wcsncmp(const wchar_t* str1,
574 const wchar_t* str2,
575 size_t i)
576{
577 dprintf2(("CRTDLL: wcsncmp(%08xh,%08xh,%08xh)\n",
578 str1,
579 str2,
580 i));
581
582 return (wcsncmp(str1, str2, i));
583}
584
585
586/*********************************************************************
587 * wcsncmp (CRTDLL.510)
588 */
589wchar_t* CDECL CRTDLL_wcsncpy( wchar_t* str1,
590 const wchar_t* str2,
591 size_t i)
592{
593 dprintf2(("CRTDLL: wcsncpy(%s,%s,%08xh)\n",
594 str1,
595 str2,
596 i));
597
598 return (wcsncpy(str1, str2, i));
599}
600
601
602/*********************************************************************
603 * wcspbrk (CRTDLL.511)
604 */
605wchar_t* CDECL CRTDLL_wcspbrk(const wchar_t* str1,
606 const wchar_t* str2)
607{
608 dprintf2(("CRTDLL: wcspbrk(%08xh,%08xh)\n",
609 str1,
610 str2));
611
612 return (wcspbrk(str1, str2));
613}
614
615
616/*********************************************************************
617 * wcsrchr (CRTDLL.512)
618 */
619wchar_t* CDECL CRTDLL_wcsrchr(const wchar_t* str,
620 size_t i)
621{
622 dprintf2(("CRTDLL: wcsrchr(%08xh,%08xh)\n",
623 str,
624 i));
625
626 return (wcsrchr(str, i));
627}
628
629
630/*********************************************************************
631 * wcsspn (CRTDLL.513)
632 */
633size_t CDECL CRTDLL_wcsspn(const wchar_t* str1,
634 const wchar_t* str2)
635{
636 dprintf2(("CRTDLL: wcsspn(%08xh,%08xh)\n",
637 str1,
638 str2));
639
640 return (wcsspn(str1, str2));
641}
642
643
644/*********************************************************************
645 * wcsstr (CRTDLL.514)
646 */
647wchar_t* CDECL CRTDLL_wcsstr(const wchar_t* str1,
648 const wchar_t* str2)
649{
650 dprintf2(("CRTDLL: wcsstr(%s,%s)\n",
651 str1,
652 str2));
653
654 return (wcsstr(str1, str2));
655}
656
657
658/*********************************************************************
659 * wcstod (CRTDLL.515)
660 */
661double CDECL CRTDLL_wcstod( const wchar_t *nptr, wchar_t **endptr )
662{
663 dprintf2(("CRTDLL: wcstod\n"));
664 return (wcstod(nptr, endptr));
665}
666
667
668/*********************************************************************
669 * wcstok (CRTDLL.516)
670 */
671wchar_t * CDECL CRTDLL_wcstok( wchar_t *s1, const wchar_t *s2, wchar_t **ptr )
672{
673 dprintf2(("CRTDLL: wcstok(%08xh, %08xh, %08xh)\n",s1,s2,ptr));
674 return (wcstok(s1, s2, ptr));
675}
676
677
678/*********************************************************************
679 * wcstol (CRTDLL.517)
680 */
681long int CDECL CRTDLL_wcstol( const wchar_t *s1, wchar_t **s2, int i )
682{
683 dprintf2(("CRTDLL: wcstol(%08xh, %08xh, %08xh)\n",s1,s2,i));
684 return (wcstol(s1, s2, i));
685}
686
687
688/*********************************************************************
689 * wcstombs (CRTDLL.518)
690 */
691size_t CDECL CRTDLL_wcstombs( char *s, const wchar_t *pwcs, size_t n )
692{
693 dprintf2(("CRTDLL: wcstombs(%08xh, %08xh, %08xh)\n",s,pwcs,n));
694 return (wcstombs(s, pwcs, n));
695}
696
697
698/*********************************************************************
699 * wcstoul (CRTDLL.519)
700 */
701unsigned long int CDECL CRTDLL_wcstoul( const wchar_t *s1, wchar_t **s2, int i )
702{
703 dprintf2(("CRTDLL: wcstoul(%08xh, %08xh, %08xh)\n",s1,s2,i));
704 return (wcstoul(s1, s2, i));
705}
706
707
708/*********************************************************************
709 * wcsxfrm (CRTDLL.520)
710 */
711size_t CDECL CRTDLL_wcsxfrm( wchar_t *s1, const wchar_t *s2, size_t n )
712{
713 dprintf2(("CRTDLL: wcsxfrm\n"));
714 return (wcsxfrm(s1, s2, n));
715}
716
717
718/*********************************************************************
719 * wctomb (CRTDLL.521)
720 */
721int CDECL CRTDLL_wctomb( LPSTR dst, WCHAR ch )
722{
723 dprintf2(("CRTDLL: wctomb\n"));
724 //return WideCharToMultiByte( CP_ACP, 0, &ch, 1, dst, 6, NULL, NULL );
725 return (wctomb((char*)dst,ch));
726}
Note: See TracBrowser for help on using the repository browser.