Fix comment.
[kopensolaris-gnu/glibc.git] / wcsmbs / wchar.h
1 /* Copyright (C) 1995, 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
2    This file is part of the GNU C Library.
3
4    The GNU C Library is free software; you can redistribute it and/or
5    modify it under the terms of the GNU Library General Public License as
6    published by the Free Software Foundation; either version 2 of the
7    License, or (at your option) any later version.
8
9    The GNU C Library is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12    Library General Public License for more details.
13
14    You should have received a copy of the GNU Library General Public
15    License along with the GNU C Library; see the file COPYING.LIB.  If not,
16    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17    Boston, MA 02111-1307, USA.  */
18
19 /*
20  *      ISO C Standard, Amendment 1, 7.16.4
21  *      General wide-string utilities   <wchar.h>
22  */
23
24 #ifndef _WCHAR_H
25
26 #ifndef __need_mbstate_t
27 # define _WCHAR_H 1
28 # include <features.h>
29 #endif
30
31 #ifdef _WCHAR_H
32 /* Get FILE definition.  */
33 # define __need_FILE
34 # include <stdio.h>
35 /* Get va_list definition.  */
36 # define __need___va_list
37 # include <stdarg.h>
38
39 /* Get size_t, wchar_t, wint_t and NULL from <stddef.h>.  */
40 # define __need_size_t
41 # define __need_wchar_t
42 # define __need_NULL
43 #endif
44 #define __need_wint_t
45 #include <stddef.h>
46
47 /* We try to get wint_t from <stddef.h>, but not all GCC versions define it
48    there.  So define it ourselves if it remains undefined.  */
49 #ifndef _WINT_T
50 /* Integral type unchanged by default argument promotions that can
51    hold any value corresponding to members of the extended character
52    set, as well as at least one value that does not correspond to any
53    member of the extended character set.  */
54 # define _WINT_T
55 typedef unsigned int wint_t;
56 #endif
57
58
59 #ifndef __mbstate_t_defined
60 # define __mbstate_t_defined    1
61 /* Conversion state information.  */
62 typedef struct
63 {
64   int count;            /* Number of bytes needed for the current character. */
65   wint_t value;         /* Value so far.  */
66 } __mbstate_t;
67 #endif
68 #undef __need_mbstate_t
69
70
71 /* The rest of the file is only used if used if __need_mbstate_t is not
72    defined.  */
73 #ifdef _WCHAR_H
74
75 /* Public type.  */
76 typedef __mbstate_t mbstate_t;
77
78 #ifndef WCHAR_MIN
79 /* These constants might also be defined in <inttypes.h>.  */
80 # define WCHAR_MIN ((wchar_t) 0)
81 # define WCHAR_MAX (~WCHAR_MIN)
82 #endif
83
84 #ifndef WEOF
85 # define WEOF (0xffffffffu)
86 #endif
87
88 /* For XPG4 compliance we have to define the stuff from <wctype.h> here
89    as well.  */
90 #if defined __USE_XOPEN && !defined __USE_UNIX98
91 # include <wctype.h>
92 #endif
93
94 /* This incomplete type is defined in <time.h> but needed here because
95    of `wcsftime'.  */
96 struct tm;
97
98
99 __BEGIN_DECLS
100
101 /* Copy SRC to DEST.  */
102 extern wchar_t *wcscpy __P ((wchar_t *__restrict __dest,
103                              __const wchar_t *__restrict __src));
104 /* Copy no more than N wide-characters of SRC to DEST.  */
105 extern wchar_t *wcsncpy __P ((wchar_t *__restrict __dest,
106                               __const wchar_t *__restrict __src, size_t __n));
107
108 /* Append SRC onto DEST.  */
109 extern wchar_t *wcscat __P ((wchar_t *__restrict __dest,
110                              __const wchar_t *__restrict __src));
111 /* Append no more than N wide-characters of SRC onto DEST.  */
112 extern wchar_t *wcsncat __P ((wchar_t *__restrict __dest,
113                               __const wchar_t *__restrict __src, size_t __n));
114
115 /* Compare S1 and S2.  */
116 extern int wcscmp __P ((__const wchar_t *__s1, __const wchar_t *__s2));
117 /* Compare N wide-characters of S1 and S2.  */
118 extern int wcsncmp __P ((__const wchar_t *__s1, __const wchar_t *__s2,
119                          size_t __n));
120
121 #ifdef __USE_GNU
122 /* Compare S1 and S2, ignoring case.  */
123 extern int wcscasecmp __P ((__const wchar_t *__s1, __const wchar_t *__s2));
124
125 /* Compare no more than N chars of S1 and S2, ignoring case.  */
126 extern int wcsncasecmp __P ((__const wchar_t *__s1, __const wchar_t *__s2,
127                              size_t __n));
128
129 /* Similar to the two functions above but take the information from
130    the provided locale and not the global locale.  */
131 # include <xlocale.h>
132
133 extern int __wcscasecmp_l __P ((__const wchar_t *__s1, __const wchar_t *__s2,
134                                 __locale_t __loc));
135
136 extern int __wcsncasecmp_l __P ((__const wchar_t *__s1, __const wchar_t *__s2,
137                                  size_t __n, __locale_t __loc));
138 #endif
139
140 /* Compare S1 and S2, both interpreted as appropriate to the
141    LC_COLLATE category of the current locale.  */
142 extern int wcscoll __P ((__const wchar_t *__s1, __const wchar_t *__s2));
143 /* Transform S2 into array pointed to by S1 such that if wcscmp is
144    applied to two transformed strings the result is the as applying
145    `wcscoll' to the original strings.  */
146 extern size_t wcsxfrm __P ((wchar_t *__restrict __s1,
147                             __const wchar_t *__restrict __s2, size_t __n));
148
149 #ifdef __USE_GNU
150 /* Similar to the two functions above but take the information from
151    the provided locale and not the global locale.  */
152
153 /* Compare S1 and S2, both interpreted as appropriate to the
154    LC_COLLATE category of the given locale.  */
155 extern int __wcscoll_l __P ((__const wchar_t *__s1, __const wchar_t *__s2,
156                              __locale_t __loc));
157 /* Transform S2 into array pointed to by S1 such that if wcscmp is
158    applied to two transformed strings the result is the as applying
159    `wcscoll' to the original strings.  */
160 extern size_t __wcsxfrm_l __P ((wchar_t *__s1, __const wchar_t *__s2,
161                                 size_t __n, __locale_t __loc));
162
163 /* Duplicate S, returning an identical malloc'd string.  */
164 extern wchar_t *wcsdup __P ((__const wchar_t *__s));
165 #endif
166
167 /* Find the first occurrence of WC in WCS.  */
168 extern wchar_t *wcschr __P ((__const wchar_t *__wcs, wchar_t __wc));
169 /* Find the last occurrence of WC in WCS.  */
170 extern wchar_t *wcsrchr __P ((__const wchar_t *__wcs, wchar_t __wc));
171
172 #ifdef __USE_GNU
173 /* This funciton is similar to `wcschr'.  But it returns a pointer to
174    the closing NUL wide character in case C is not found in S.  */
175 extern wchar_t *wcschrnul __P ((__const wchar_t *__s, wchar_t __wc));
176 #endif
177
178 /* Return the length of the initial segmet of WCS which
179    consists entirely of wide characters not in REJECT.  */
180 extern size_t wcscspn __P ((__const wchar_t *__wcs,
181                             __const wchar_t *__reject));
182 /* Return the length of the initial segmet of WCS which
183    consists entirely of wide characters in  ACCEPT.  */
184 extern size_t wcsspn __P ((__const wchar_t *__wcs, __const wchar_t *__accept));
185 /* Find the first occurrence in WCS of any character in ACCEPT.  */
186 extern wchar_t *wcspbrk __P ((__const wchar_t *__wcs,
187                               __const wchar_t *__accept));
188 /* Find the first occurrence of NEEDLE in HAYSTACK.  */
189 extern wchar_t *wcsstr __P ((__const wchar_t *__haystack,
190                              __const wchar_t *__needle));
191
192 #if defined __USE_XOPEN && !defined __USE_UNIX98
193 /* Another name for `wcsstr' from XPG4.  */
194 extern wchar_t *wcswcs __P ((__const wchar_t *__haystack,
195                              __const wchar_t *__needle));
196 #endif
197
198 /* Divide WCS into tokens separated by characters in DELIM.  */
199 extern wchar_t *wcstok __P ((wchar_t *__restrict __s,
200                              __const wchar_t *__restrict __delim,
201                              wchar_t **__restrict __ptr));
202
203 /* Return the number of wide characters in S.  */
204 extern size_t __wcslen __P ((__const wchar_t *__s));
205 extern size_t wcslen __P ((__const wchar_t *__s));
206
207 #ifdef __USE_GNU
208 /* Return the number of wide characters in S, but at most MAXLEN.  */
209 extern size_t wcsnlen __P ((__const wchar_t *__s, size_t __maxlen));
210 #endif
211
212
213 /* Search N wide characters of S for C.  */
214 extern wchar_t *wmemchr __P ((__const wchar_t *__s, wchar_t __c, size_t __n));
215
216 /* Compare N wide characters of S1 and S2.  */
217 extern int wmemcmp __P ((__const wchar_t *__restrict __s1,
218                          __const wchar_t *__restrict __s2, size_t __n));
219
220 /* Copy N wide characters of SRC to DEST.  */
221 extern wchar_t *wmemcpy __P ((wchar_t *__restrict __s1,
222                               __const wchar_t *__restrict __s2, size_t __n));
223
224 /* Copy N wide characters of SRC to DEST, guaranteeing
225    correct behavior for overlapping strings.  */
226 extern wchar_t *wmemmove __P ((wchar_t *__s1, __const wchar_t *__s2,
227                                size_t __n));
228
229 /* Set N wide characters of S to C.  */
230 extern wchar_t *wmemset __P ((wchar_t *__s, wchar_t __c, size_t __n));
231
232 #ifdef __USE_GNU
233 /* Copy N wide characters of SRC to DEST and return pointer to following
234    wide character.  */
235 extern wchar_t *wmempcpy __P ((wchar_t *__restrict __s1,
236                                __const wchar_t *__restrict __s2, size_t __n));
237 #endif
238
239
240 /* Determine whether C constitutes a valid (one-byte) multibyte
241    character.  */
242 extern wint_t btowc __P ((int __c));
243
244 /* Determine whether C corresponds to a member of the extended
245    character set whose multibyte representation is a single byte.  */
246 extern int wctob __P ((wint_t __c));
247
248 /* Determine whether PS points to an object representing the initial
249    state.  */
250 extern int mbsinit __P ((__const mbstate_t *__ps));
251
252 /* Write wide character representation of multibyte character pointed
253    to by S to PWC.  */
254 extern size_t mbrtowc __P ((wchar_t *__restrict __pwc,
255                             __const char *__restrict __s, size_t __n,
256                             mbstate_t *__p));
257
258 /* Write multibyte representation of wide character WC to S.  */
259 extern size_t wcrtomb __P ((char *__restrict __s, wchar_t __wc,
260                             mbstate_t *__restrict __ps));
261
262 /* Return number of bytes in multibyte character pointed to by S.  */
263 extern size_t __mbrlen __P ((__const char *__restrict __s, size_t __n,
264                              mbstate_t *__restrict __ps));
265 extern size_t mbrlen __P ((__const char *__restrict __s, size_t __n,
266                            mbstate_t *__restrict __ps));
267
268 #if defined __OPTIMIZE__ && !defined __OPTIMIZE_SIZE__ \
269     && defined __USE_EXTERN_INLINES
270 /* Define inline function as optimization.  */
271 extern __inline size_t mbrlen (__const char *__restrict __s, size_t __n,
272                                mbstate_t *__restrict __ps) __THROW
273 { return (__ps != NULL
274           ? mbrtowc (NULL, __s, __n, __ps) : __mbrlen (__s, __n, NULL)); }
275 #endif
276
277 /* Write wide character representation of multibyte character string
278    SRC to DST.  */
279 extern size_t mbsrtowcs __P ((wchar_t *__restrict __dst,
280                               __const char **__restrict __src,
281                               size_t __len, mbstate_t *__restrict __ps));
282
283 /* Write multibyte character representation of wide character string
284    SRC to DST.  */
285 extern size_t wcsrtombs __P ((char *__restrict __dst,
286                               __const wchar_t **__restrict __src,
287                               size_t __len, mbstate_t *__restrict __ps));
288
289
290 #ifdef  __USE_GNU
291 /* Write wide character representation of at most NMC bytes of the
292    multibyte character string SRC to DST.  */
293 extern size_t mbsnrtowcs __P ((wchar_t *__restrict __dst,
294                                __const char **__restrict __src, size_t __nmc,
295                                size_t __len, mbstate_t *__restrict __ps));
296
297 /* Write multibyte character representation of at most NWC characters
298    from the wide character string SRC to DST.  */
299 extern size_t wcsnrtombs __P ((char *__restrict __dst,
300                                __const wchar_t **__restrict __src,
301                                size_t __nwc, size_t __len,
302                                mbstate_t *__restrict __ps));
303 #endif  /* use GNU */
304
305
306 /* The following functions are extensions found in X/Open CAE.  */
307 #ifdef __USE_XOPEN
308 /* Determine number of column positions required for C.  */
309 extern int wcwidth __P ((wint_t __c));
310
311 /* Determine number of column positions required for first N wide
312    characters (or fewer if S ends before this) in S.  */
313 extern int wcswidth __P ((__const wchar_t *__s, size_t __n));
314 #endif  /* Use X/Open.  */
315
316
317 /* Convert initial portion of the wide string NPTR to `double'
318    representation.  */
319 extern double wcstod __P ((__const wchar_t *__restrict __nptr,
320                            wchar_t **__restrict __endptr));
321
322 #ifdef __USE_ISOC9X
323 /* Likewise for `float' and `long double' sizes of floating-point numbers.  */
324 extern float wcstof __P ((__const wchar_t *__restrict __nptr,
325                           wchar_t **__restrict __endptr));
326 extern __long_double_t wcstold __P ((__const wchar_t *__restrict __nptr,
327                                      wchar_t **__restrict __endptr));
328 #endif /* C9x */
329
330
331 /* Convert initial portion of wide string NPTR to `long int'
332    representation.  */
333 extern long int wcstol __P ((__const wchar_t *__restrict __nptr,
334                              wchar_t **__restrict __endptr, int __base));
335
336 /* Convert initial portion of wide string NPTR to `unsigned long int'
337    representation.  */
338 extern unsigned long int wcstoul __P ((__const wchar_t *__restrict __nptr,
339                                        wchar_t **__restrict __endptr,
340                                        int __base));
341
342 #if defined __GNUC__ && defined __USE_GNU
343 /* Convert initial portion of wide string NPTR to `long int'
344    representation.  */
345 __extension__
346 extern long long int wcstoq __P ((__const wchar_t *__restrict __nptr,
347                                   wchar_t **__restrict __endptr, int __base));
348
349 /* Convert initial portion of wide string NPTR to `unsigned long long int'
350    representation.  */
351 __extension__
352 extern unsigned long long int wcstouq __P ((__const wchar_t *__restrict __nptr,
353                                             wchar_t **__restrict __endptr,
354                                             int __base));
355 #endif /* GCC and use GNU.  */
356
357 #if defined __USE_ISOC9X || (defined __GNUC__ && defined __USE_GNU)
358 /* Convert initial portion of wide string NPTR to `long int'
359    representation.  */
360 __extension__
361 extern long long int wcstoll __P ((__const wchar_t *__restrict __nptr,
362                                    wchar_t **__restrict __endptr, int __base));
363
364 /* Convert initial portion of wide string NPTR to `unsigned long long int'
365    representation.  */
366 __extension__
367 extern unsigned long long int wcstoull __P ((__const wchar_t *
368                                              __restrict __nptr,
369                                              wchar_t **__restrict __endptr,
370                                              int __base));
371 #endif /* ISO C 9X or GCC and GNU.  */
372
373 #ifdef __USE_GNU
374 /* The concept of one static locale per category is not very well
375    thought out.  Many applications will need to process its data using
376    information from several different locales.  Another application is
377    the implementation of the internationalization handling in the
378    upcoming ISO C++ standard library.  To support this another set of
379    the functions using locale data exist which have an additional
380    argument.
381
382    Attention: all these functions are *not* standardized in any form.
383    This is a proof-of-concept implementation.  */
384
385 /* Structure for reentrant locale using functions.  This is an
386    (almost) opaque type for the user level programs.  */
387 # include <xlocale.h>
388
389 /* Special versions of the functions above which take the locale to
390    use as an additional parameter.  */
391 extern long int __wcstol_l __P ((__const wchar_t *__restrict __nptr,
392                                  wchar_t **__restrict __endptr, int __base,
393                                  __locale_t __loc));
394
395 extern unsigned long int __wcstoul_l __P ((__const wchar_t *__restrict __nptr,
396                                            wchar_t **__restrict __endptr,
397                                            int __base, __locale_t __loc));
398
399 __extension__
400 extern long long int __wcstoll_l __P ((__const wchar_t *__restrict __nptr,
401                                        wchar_t **__restrict __endptr,
402                                        int __base, __locale_t __loc));
403
404 __extension__
405 extern unsigned long long int __wcstoull_l __P ((__const wchar_t *__restrict
406                                                  __nptr,
407                                                  wchar_t **__restrict __endptr,
408                                                  int __base,
409                                                  __locale_t __loc));
410
411 extern double __wcstod_l __P ((__const wchar_t *__restrict __nptr,
412                                wchar_t **__restrict __endptr,
413                                __locale_t __loc));
414
415 extern float __wcstof_l __P ((__const wchar_t *__restrict __nptr,
416                               wchar_t **__restrict __endptr,
417                               __locale_t __loc));
418
419 extern __long_double_t __wcstold_l __P ((__const wchar_t *__restrict __nptr,
420                                          wchar_t **__restrict __endptr,
421                                          __locale_t __loc));
422 #endif /* GNU */
423
424
425 /* The internal entry points for `wcstoX' take an extra flag argument
426    saying whether or not to parse locale-dependent number grouping.  */
427 extern double __wcstod_internal __P ((__const wchar_t *__restrict __nptr,
428                                       wchar_t **__restrict __endptr,
429                                       int __group));
430 extern float __wcstof_internal __P ((__const wchar_t *__restrict __nptr,
431                                      wchar_t **__restrict __endptr,
432                                      int __group));
433 extern __long_double_t __wcstold_internal __P ((__const wchar_t *
434                                                 __restrict __nptr,
435                                                 wchar_t **__restrict __endptr,
436                                                 int __group));
437
438 #ifndef __wcstol_internal_defined
439 extern long int __wcstol_internal __P ((__const wchar_t *__restrict __nptr,
440                                         wchar_t **__restrict __endptr,
441                                         int __base, int __group));
442 # define __wcstol_internal_defined      1
443 #endif
444 #ifndef __wcstoul_internal_defined
445 extern unsigned long int __wcstoul_internal __P ((__const wchar_t *
446                                                   __restrict __nptr,
447                                                   wchar_t **
448                                                   __restrict __endptr,
449                                                   int __base, int __group));
450 # define __wcstoul_internal_defined     1
451 #endif
452 #ifndef __wcstoll_internal_defined
453 __extension__
454 extern long long int __wcstoll_internal __P ((__const wchar_t *
455                                               __restrict __nptr,
456                                               wchar_t **__restrict __endptr,
457                                               int __base, int __group));
458 # define __wcstoll_internal_defined     1
459 #endif
460 #ifndef __wcstoull_internal_defined
461 __extension__
462 extern unsigned long long int __wcstoull_internal __P ((__const wchar_t *
463                                                         __restrict __nptr,
464                                                         wchar_t **
465                                                         __restrict __endptr,
466                                                         int __base,
467                                                         int __group));
468 # define __wcstoull_internal_defined    1
469 #endif
470
471
472 #if defined __OPTIMIZE__ && __GNUC__ >= 2
473 /* Define inline functions which call the internal entry points.  */
474
475 extern __inline double wcstod (__const wchar_t *__restrict __nptr,
476                                wchar_t **__restrict __endptr) __THROW
477 { return __wcstod_internal (__nptr, __endptr, 0); }
478 extern __inline long int wcstol (__const wchar_t *__restrict __nptr,
479                                  wchar_t **__restrict __endptr,
480                                  int __base) __THROW
481 { return __wcstol_internal (__nptr, __endptr, __base, 0); }
482 extern __inline unsigned long int wcstoul (__const wchar_t *__restrict __nptr,
483                                            wchar_t **__restrict __endptr,
484                                            int __base) __THROW
485 { return __wcstoul_internal (__nptr, __endptr, __base, 0); }
486
487 # ifdef __USE_GNU
488 extern __inline float wcstof (__const wchar_t *__restrict __nptr,
489                               wchar_t **__restrict __endptr) __THROW
490 { return __wcstof_internal (__nptr, __endptr, 0); }
491 extern __inline __long_double_t wcstold (__const wchar_t *__restrict __nptr,
492                                          wchar_t **__restrict __endptr) __THROW
493 { return __wcstold_internal (__nptr, __endptr, 0); }
494
495
496 __extension__
497 extern __inline long long int wcstoq (__const wchar_t *__restrict __nptr,
498                                       wchar_t **__restrict __endptr,
499                                       int __base) __THROW
500 { return __wcstoll_internal (__nptr, __endptr, __base, 0); }
501 __extension__
502 extern __inline unsigned long long int wcstouq (__const wchar_t *
503                                                 __restrict __nptr,
504                                                 wchar_t **__restrict __endptr,
505                                                 int __base) __THROW
506 { return __wcstoull_internal (__nptr, __endptr, __base, 0); }
507 # endif /* Use GNU.  */
508 #endif /* Optimizing GCC >=2.  */
509
510
511 #ifdef  __USE_GNU
512 /* Copy SRC to DEST, returning the address of the terminating L'\0' in
513    DEST.  */
514 extern wchar_t *wcpcpy __P ((wchar_t *__dest, __const wchar_t *__src));
515
516 /* Copy no more than N characters of SRC to DEST, returning the address of
517    the last character written into DEST.  */
518 extern wchar_t *wcpncpy __P ((wchar_t *__dest, __const wchar_t *__src,
519                               size_t __n));
520 #endif  /* use GNU */
521
522
523 /* Wide character I/O functions.  */
524 #ifdef __USE_ISOC9X
525
526 /* Select orientation for stream.  */
527 extern int fwide __P ((FILE *__fp, int __mode));
528
529
530 /* Write formatted output to STREAM.  */
531 extern int fwprintf __P ((FILE *__restrict __stream,
532                           __const wchar_t *__restrict __format, ...))
533      /* __attribute__ ((__format__ (__wprintf__, 2, 3))) */;
534 /* Write formatted output to stdout.  */
535 extern int wprintf __P ((__const wchar_t *__restrict __format, ...))
536      /* __attribute__ ((__format__ (__wprintf__, 1, 2))) */;
537 /* Write formatted output of at most N characters to S.  */
538 extern int swprintf __P ((wchar_t *__restrict __s, size_t __n,
539                           __const wchar_t *__restrict __format, ...))
540      /* __attribute__ ((__format__ (__wprintf__, 3, 4))) */;
541
542 /* Write formatted output to S from argument list ARG.  */
543 extern int vfwprintf __P ((FILE *__restrict __s,
544                            __const wchar_t *__restrict __format,
545                            __gnuc_va_list __arg))
546      /* __attribute__ ((__format__ (__wprintf__, 2, 0))) */;
547 /* Write formatted output to stdout from argument list ARG.  */
548 extern int vwprintf __P ((__const wchar_t *__restrict __format,
549                           __gnuc_va_list __arg))
550      /* __attribute__ ((__format__ (__wprintf__, 1, 0))) */;
551 /* Write formatted output of at most N character to S from argument
552    list ARG.  */
553 extern int vswprintf __P ((wchar_t *__restrict __s, size_t __n,
554                            __const wchar_t *__restrict __format,
555                            __gnuc_va_list __arg))
556      /* __attribute__ ((__format__ (__wprintf__, 3, 0))) */;
557
558
559 /* Read formatted input from STREAM.  */
560 extern int fwscanf __P ((FILE *__restrict __stream,
561                          __const wchar_t *__restrict __format, ...))
562      /* __attribute__ ((__format__ (__wscanf__, 2, 3))) */;
563 /* Read formatted input from stdin.  */
564 extern int wscanf __P ((__const wchar_t *__restrict __format, ...))
565      /* __attribute__ ((__format__ (__wscanf__, 1, 2))) */;
566 /* Read formatted input from S.  */
567 extern int swscanf __P ((__const wchar_t *__restrict __s,
568                          __const wchar_t *__restrict __format, ...))
569      /* __attribute__ ((__format__ (__wscanf__, 2, 3))) */;
570
571 /* Read formatted input from S into argument list ARG.  */
572 extern int vfwscanf __P ((FILE *__restrict __s,
573                           __const wchar_t *__restrict __format,
574                           __gnuc_va_list __arg))
575      /* __attribute__ ((__format__ (__wscanf__, 2, 0))) */;
576 /* Read formatted input from stdin into argument list ARG.  */
577 extern int vwscanf __P ((__const wchar_t *__restrict __format,
578                          __gnuc_va_list __arg))
579      /* __attribute__ ((__format__ (__wscanf__, 1, 0))) */;
580 /* Read formatted input from S into argument list ARG.  */
581 extern int vswscanf __P ((__const wchar_t *__restrict __s,
582                           __const wchar_t *__restrict __format,
583                           __gnuc_va_list __arg))
584      /* __attribute__ ((__format__ (__wscanf__, 2, 0))) */;
585
586
587 /* Read a character from STREAM.  */
588 extern wint_t fgetwc __P ((FILE *__stream));
589 extern wint_t getwc __P ((FILE *__stream));
590
591 /* Read a character from stdin.  */
592 extern wint_t getwchar __P ((void));
593
594 #ifdef __USE_GNU
595 /* These are defined to be equivalent to the `char' functions defined
596    in POSIX.1:1996.  */
597 extern wint_t getwc_unlocked __P ((FILE *__stream));
598 extern wint_t getwchar_unlocked __P ((void));
599
600 /* This is the wide character version of a GNU extension.  */
601 extern wint_t fgetwc_unlocked __P ((FILE *__stream));
602 #endif /* Use POSIX or MISC.  */
603
604
605 /* Write a character to STREAM.  */
606 extern wint_t fputwc __P ((wchar_t __wc, FILE *__stream));
607 extern wint_t putwc __P ((wchar_t __wc, FILE *__stream));
608
609 /* Write a character to stdout.  */
610 extern wint_t putwchar __P ((wchar_t __wc));
611
612 #ifdef __USE_GNU
613 /* Faster version when locking is not necessary.  */
614 extern wint_t fputwc_unlocked __P ((wchar_t __wc, FILE *__stream));
615
616 /* These are defined to be equivalent to the `char' functions defined
617    in POSIX.1:1996.  */
618 extern wint_t putwc_unlocked __P ((wchar_t __wc, FILE *__stream));
619 extern wint_t putwchar_unlocked __P ((wchar_t __wc));
620 #endif
621
622
623 /* Get a newline-terminated wide character string of finite length
624    from STREAM.  */
625 extern wchar_t *fgetws __P ((wchar_t *__restrict __ws, int __n,
626                              FILE *__restrict __stream));
627
628 #ifdef __USE_GNU
629 /* This function does the same as `fgetws' but does not lock the stream.  */
630 extern wchar_t *fgetws_unlocked __P ((wchar_t *__restrict __ws, int __n,
631                                       FILE *__restrict __stream));
632 #endif
633
634
635 /* Write a string to STREAM.  */
636 extern int fputws __P ((__const wchar_t *__restrict __ws,
637                         FILE *__restrict __stream));
638
639 #ifdef __USE_GNU
640 /* This function does the same as `fputws' but does not lock the stream.  */
641 extern int fputws_unlocked __P ((__const wchar_t *__restrict __ws,
642                                  FILE *__restrict __stream));
643 #endif
644
645
646 /* Push a character back onto the input buffer of STREAM.  */
647 extern wint_t ungetwc __P ((wint_t __wc, FILE *__stream));
648
649
650 /* Format TP into S according to FORMAT.
651    Write no more than MAXSIZE wide characters and return the number
652    of wide characters written, or 0 if it would exceed MAXSIZE.  */
653 extern size_t wcsftime __P ((wchar_t *__restrict __s, size_t __maxsize,
654                              __const wchar_t *__restrict __format,
655                              __const struct tm *__restrict __tp));
656 #endif /* Use ISO C9x. */
657
658 /* The X/Open standard demands that most of the functions defined in
659    the <wctype.h> header must also appear here.  This is probably
660    because some X/Open members wrote their implementation before the
661    ISO C standard was published and introduced the better solution.
662    We have to provide these definitions for compliance reasons but we
663    do this nonsense only if really necessary.  */
664 #if defined __USE_UNIX98 && !defined __USE_GNU
665 # define __need_iswxxx
666 # include <wctype.h>
667 #endif
668
669 __END_DECLS
670
671 #endif  /* _WCHAR_H defined */
672
673 #endif /* wchar.h  */