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

Last change on this file since 5100 was 5090, checked in by sandervl, 25 years ago

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