Dr Andrew Scott G7VAV

My photo
 
March 2024
Mo Tu We Th Fr Sa Su
26 27 28 29 1 2 3
4 5 6 7 8 9 10
11 12 13 14 15 16 17
18 19 20 21 22 23 24
25 26 27 28 29 30 31
1 2 3 4 5 6 7


wchar.h
001: /* Copyright (C) 1995-2008, 2009, 2010, 2011 Free Software Foundation, Inc.
002:    This file is part of the GNU C Library.
003: 
004:    The GNU C Library is free software; you can redistribute it and/or
005:    modify it under the terms of the GNU Lesser General Public
006:    License as published by the Free Software Foundation; either
007:    version 2.1 of the License, or (at your option) any later version.
008: 
009:    The GNU C Library is distributed in the hope that it will be useful,
010:    but WITHOUT ANY WARRANTY; without even the implied warranty of
011:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
012:    Lesser General Public License for more details.
013: 
014:    You should have received a copy of the GNU Lesser General Public
015:    License along with the GNU C Library; if not, write to the Free
016:    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
017:    02111-1307 USA.  */
018: 
019: /*
020:  *      ISO C99 Standard: 7.24
021:  *      Extended multibyte and wide character utilities <wchar.h>
022:  */
023: 
024: #ifndef _WCHAR_H
025: 
026: #if !defined __need_mbstate_t && !defined __need_wint_t
027: # define _WCHAR_H 1
028: # include <features.h>
029: #endif
030: 
031: #ifdef _WCHAR_H
032: /* Get FILE definition.  */
033: # define __need___FILE
034: # if defined __USE_UNIX98 || defined __USE_XOPEN2K
035: #  define __need_FILE
036: # endif
037: # include <stdio.h>
038: /* Get va_list definition.  */
039: # define __need___va_list
040: # include <stdarg.h>
041: 
042: # include <bits/wchar.h>
043: 
044: /* Get size_t, wchar_t, wint_t and NULL from <stddef.h>.  */
045: # define __need_size_t
046: # define __need_wchar_t
047: # define __need_NULL
048: #endif
049: #if defined _WCHAR_H || defined __need_wint_t || !defined __WINT_TYPE__
050: # undef __need_wint_t
051: # define __need_wint_t
052: # include <stddef.h>
053: 
054: /* We try to get wint_t from <stddef.h>, but not all GCC versions define it
055:    there.  So define it ourselves if it remains undefined.  */
056: # ifndef _WINT_T
057: /* Integral type unchanged by default argument promotions that can
058:    hold any value corresponding to members of the extended character
059:    set, as well as at least one value that does not correspond to any
060:    member of the extended character set.  */
061: #  define _WINT_T
062: typedef unsigned int wint_t;
063: # else
064: /* Work around problems with the <stddef.h> file which doesn't put
065:    wint_t in the std namespace.  */
066: #  if defined __cplusplus && defined _GLIBCPP_USE_NAMESPACES \
067:       && defined __WINT_TYPE__
068: __BEGIN_NAMESPACE_STD
069: typedef __WINT_TYPE__ wint_t;
070: __END_NAMESPACE_STD
071: #  endif
072: # endif
073: 
074: /* Tell the caller that we provide correct C++ prototypes.  */
075: # if defined __cplusplus && __GNUC_PREREQ (4, 4)
076: #  define __CORRECT_ISO_CPP_WCHAR_H_PROTO
077: # endif
078: #endif
079: 
080: #if (defined _WCHAR_H || defined __need_mbstate_t) && !defined __mbstate_t_defined
081: # define __mbstate_t_defined    1
082: /* Conversion state information.  */
083: typedef struct
084: {
085:   int __count;
086:   union
087:   {
088: # ifdef __WINT_TYPE__
089:     __WINT_TYPE__ __wch;
090: # else
091:     wint_t __wch;
092: # endif
093:     char __wchb[4];
094:   } __value;            /* Value so far.  */
095: } __mbstate_t;
096: #endif
097: #undef __need_mbstate_t
098: 
099: 
100: /* The rest of the file is only used if used if __need_mbstate_t is not
101:    defined.  */
102: #ifdef _WCHAR_H
103: 
104: __BEGIN_NAMESPACE_C99
105: /* Public type.  */
106: typedef __mbstate_t mbstate_t;
107: __END_NAMESPACE_C99
108: #ifdef __USE_GNU
109: __USING_NAMESPACE_C99(mbstate_t)
110: #endif
111: 
112: #ifndef WCHAR_MIN
113: /* These constants might also be defined in <inttypes.h>.  */
114: # define WCHAR_MIN __WCHAR_MIN
115: # define WCHAR_MAX __WCHAR_MAX
116: #endif
117: 
118: #ifndef WEOF
119: # define WEOF (0xffffffffu)
120: #endif
121: 
122: /* For XPG4 compliance we have to define the stuff from <wctype.h> here
123:    as well.  */
124: #if defined __USE_XOPEN && !defined __USE_UNIX98
125: # include <wctype.h>
126: #endif
127: 
128: 
129: __BEGIN_DECLS
130: 
131: __BEGIN_NAMESPACE_STD
132: /* This incomplete type is defined in <time.h> but needed here because
133:    of `wcsftime'.  */
134: struct tm;
135: __END_NAMESPACE_STD
136: /* XXX We have to clean this up at some point.  Since tm is in the std
137:    namespace but wcsftime is in __c99 the type wouldn't be found
138:    without inserting it in the global namespace.  */
139: __USING_NAMESPACE_STD(tm)
140: 
141: 
142: __BEGIN_NAMESPACE_STD
143: /* Copy SRC to DEST.  */
144: extern wchar_t *wcscpy (wchar_t *__restrict __dest,
145:                         __const wchar_t *__restrict __src) __THROW;
146: /* Copy no more than N wide-characters of SRC to DEST.  */
147: extern wchar_t *wcsncpy (wchar_t *__restrict __dest,
148:                          __const wchar_t *__restrict __src, size_t __n)
149:      __THROW;
150: 
151: /* Append SRC onto DEST.  */
152: extern wchar_t *wcscat (wchar_t *__restrict __dest,
153:                         __const wchar_t *__restrict __src) __THROW;
154: /* Append no more than N wide-characters of SRC onto DEST.  */
155: extern wchar_t *wcsncat (wchar_t *__restrict __dest,
156:                          __const wchar_t *__restrict __src, size_t __n)
157:      __THROW;
158: 
159: /* Compare S1 and S2.  */
160: extern int wcscmp (__const wchar_t *__s1, __const wchar_t *__s2)
161:      __THROW __attribute_pure__;
162: /* Compare N wide-characters of S1 and S2.  */
163: extern int wcsncmp (__const wchar_t *__s1, __const wchar_t *__s2, size_t __n)
164:      __THROW __attribute_pure__;
165: __END_NAMESPACE_STD
166: 
167: #ifdef __USE_XOPEN2K8
168: /* Compare S1 and S2, ignoring case.  */
169: extern int wcscasecmp (__const wchar_t *__s1, __const wchar_t *__s2) __THROW;
170: 
171: /* Compare no more than N chars of S1 and S2, ignoring case.  */
172: extern int wcsncasecmp (__const wchar_t *__s1, __const wchar_t *__s2,
173:                         size_t __n) __THROW;
174: 
175: /* Similar to the two functions above but take the information from
176:    the provided locale and not the global locale.  */
177: # include <xlocale.h>
178: 
179: extern int wcscasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2,
180:                          __locale_t __loc) __THROW;
181: 
182: extern int wcsncasecmp_l (__const wchar_t *__s1, __const wchar_t *__s2,
183:                           size_t __n, __locale_t __loc) __THROW;
184: #endif
185: 
186: __BEGIN_NAMESPACE_STD
187: /* Compare S1 and S2, both interpreted as appropriate to the
188:    LC_COLLATE category of the current locale.  */
189: extern int wcscoll (__const wchar_t *__s1, __const wchar_t *__s2) __THROW;
190: /* Transform S2 into array pointed to by S1 such that if wcscmp is
191:    applied to two transformed strings the result is the as applying
192:    `wcscoll' to the original strings.  */
193: extern size_t wcsxfrm (wchar_t *__restrict __s1,
194:                        __const wchar_t *__restrict __s2, size_t __n) __THROW;
195: __END_NAMESPACE_STD
196: 
197: #ifdef __USE_XOPEN2K8
198: /* Similar to the two functions above but take the information from
199:    the provided locale and not the global locale.  */
200: 
201: /* Compare S1 and S2, both interpreted as appropriate to the
202:    LC_COLLATE category of the given locale.  */
203: extern int wcscoll_l (__const wchar_t *__s1, __const wchar_t *__s2,
204:                       __locale_t __loc) __THROW;
205: 
206: /* Transform S2 into array pointed to by S1 such that if wcscmp is
207:    applied to two transformed strings the result is the as applying
208:    `wcscoll' to the original strings.  */
209: extern size_t wcsxfrm_l (wchar_t *__s1, __const wchar_t *__s2,
210:                          size_t __n, __locale_t __loc) __THROW;
211: 
212: /* Duplicate S, returning an identical malloc'd string.  */
213: extern wchar_t *wcsdup (__const wchar_t *__s) __THROW __attribute_malloc__;
214: #endif
215: 
216: __BEGIN_NAMESPACE_STD
217: /* Find the first occurrence of WC in WCS.  */
218: #ifdef __CORRECT_ISO_CPP_WCHAR_H_PROTO
219: extern "C++" wchar_t *wcschr (wchar_t *__wcs, wchar_t __wc)
220:      __THROW __asm ("wcschr") __attribute_pure__;
221: extern "C++" __const wchar_t *wcschr (__const wchar_t *__wcs, wchar_t __wc)
222:      __THROW __asm ("wcschr") __attribute_pure__;
223: #else
224: extern wchar_t *wcschr (__const wchar_t *__wcs, wchar_t __wc)
225:      __THROW __attribute_pure__;
226: #endif
227: /* Find the last occurrence of WC in WCS.  */
228: #ifdef __CORRECT_ISO_CPP_WCHAR_H_PROTO
229: extern "C++" wchar_t *wcsrchr (wchar_t *__wcs, wchar_t __wc)
230:      __THROW __asm ("wcsrchr") __attribute_pure__;
231: extern "C++" __const wchar_t *wcsrchr (__const wchar_t *__wcs, wchar_t __wc)
232:      __THROW __asm ("wcsrchr") __attribute_pure__;
233: #else
234: extern wchar_t *wcsrchr (__const wchar_t *__wcs, wchar_t __wc)
235:      __THROW __attribute_pure__;
236: #endif
237: __END_NAMESPACE_STD
238: 
239: #ifdef __USE_GNU
240: /* This function is similar to `wcschr'.  But it returns a pointer to
241:    the closing NUL wide character in case C is not found in S.  */
242: extern wchar_t *wcschrnul (__const wchar_t *__s, wchar_t __wc)
243:      __THROW __attribute_pure__;
244: #endif
245: 
246: __BEGIN_NAMESPACE_STD
247: /* Return the length of the initial segmet of WCS which
248:    consists entirely of wide characters not in REJECT.  */
249: extern size_t wcscspn (__const wchar_t *__wcs, __const wchar_t *__reject)
250:      __THROW __attribute_pure__;
251: /* Return the length of the initial segmet of WCS which
252:    consists entirely of wide characters in  ACCEPT.  */
253: extern size_t wcsspn (__const wchar_t *__wcs, __const wchar_t *__accept)
254:      __THROW __attribute_pure__;
255: /* Find the first occurrence in WCS of any character in ACCEPT.  */
256: #ifdef __CORRECT_ISO_CPP_WCHAR_H_PROTO
257: extern "C++" wchar_t *wcspbrk (wchar_t *__wcs, __const wchar_t *__accept)
258:      __THROW __asm ("wcspbrk") __attribute_pure__;
259: extern "C++" __const wchar_t *wcspbrk (__const wchar_t *__wcs,
260:                                        __const wchar_t *__accept)
261:      __THROW __asm ("wcspbrk") __attribute_pure__;
262: #else
263: extern wchar_t *wcspbrk (__const wchar_t *__wcs, __const wchar_t *__accept)
264:      __THROW __attribute_pure__;
265: #endif
266: /* Find the first occurrence of NEEDLE in HAYSTACK.  */
267: #ifdef __CORRECT_ISO_CPP_WCHAR_H_PROTO
268: extern "C++" wchar_t *wcsstr (wchar_t *__haystack, __const wchar_t *__needle)
269:      __THROW __asm ("wcsstr") __attribute_pure__;
270: extern "C++" __const wchar_t *wcsstr (__const wchar_t *__haystack,
271:                                       __const wchar_t *__needle)
272:      __THROW __asm ("wcsstr") __attribute_pure__;
273: #else
274: extern wchar_t *wcsstr (__const wchar_t *__haystack, __const wchar_t *__needle)
275:      __THROW __attribute_pure__;
276: #endif
277: 
278: /* Divide WCS into tokens separated by characters in DELIM.  */
279: extern wchar_t *wcstok (wchar_t *__restrict __s,
280:                         __const wchar_t *__restrict __delim,
281:                         wchar_t **__restrict __ptr) __THROW;
282: 
283: /* Return the number of wide characters in S.  */
284: extern size_t wcslen (__const wchar_t *__s) __THROW __attribute_pure__;
285: __END_NAMESPACE_STD
286: 
287: #ifdef __USE_XOPEN
288: /* Another name for `wcsstr' from XPG4.  */
289: # ifdef __CORRECT_ISO_CPP_WCHAR_H_PROTO
290: extern "C++" wchar_t *wcswcs (wchar_t *__haystack, __const wchar_t *__needle)
291:      __THROW __asm ("wcswcs") __attribute_pure__;
292: extern "C++" __const wchar_t *wcswcs (__const wchar_t *__haystack,
293:                                       __const wchar_t *__needle)
294:      __THROW __asm ("wcswcs") __attribute_pure__;
295: # else
296: extern wchar_t *wcswcs (__const wchar_t *__haystack, __const wchar_t *__needle)
297:      __THROW __attribute_pure__;
298: # endif
299: #endif
300: 
301: #ifdef __USE_XOPEN2K8
302: /* Return the number of wide characters in S, but at most MAXLEN.  */
303: extern size_t wcsnlen (__const wchar_t *__s, size_t __maxlen)
304:      __THROW __attribute_pure__;
305: #endif
306: 
307: 
308: __BEGIN_NAMESPACE_STD
309: /* Search N wide characters of S for C.  */
310: #ifdef __CORRECT_ISO_CPP_WCHAR_H_PROTO
311: extern "C++" wchar_t *wmemchr (wchar_t *__s, wchar_t __c, size_t __n)
312:      __THROW __asm ("wmemchr") __attribute_pure__;
313: extern "C++" __const wchar_t *wmemchr (__const wchar_t *__s, wchar_t __c,
314:                                        size_t __n)
315:      __THROW __asm ("wmemchr") __attribute_pure__;
316: #else
317: extern wchar_t *wmemchr (__const wchar_t *__s, wchar_t __c, size_t __n)
318:      __THROW __attribute_pure__;
319: #endif
320: 
321: /* Compare N wide characters of S1 and S2.  */
322: extern int wmemcmp (__const wchar_t *__s1, __const wchar_t *__s2, size_t __n)
323:      __THROW __attribute_pure__;
324: 
325: /* Copy N wide characters of SRC to DEST.  */
326: extern wchar_t *wmemcpy (wchar_t *__restrict __s1,
327:                          __const wchar_t *__restrict __s2, size_t __n) __THROW;
328: 
329: /* Copy N wide characters of SRC to DEST, guaranteeing
330:    correct behavior for overlapping strings.  */
331: extern wchar_t *wmemmove (wchar_t *__s1, __const wchar_t *__s2, size_t __n)
332:      __THROW;
333: 
334: /* Set N wide characters of S to C.  */
335: extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) __THROW;
336: __END_NAMESPACE_STD
337: 
338: #ifdef __USE_GNU
339: /* Copy N wide characters of SRC to DEST and return pointer to following
340:    wide character.  */
341: extern wchar_t *wmempcpy (wchar_t *__restrict __s1,
342:                           __const wchar_t *__restrict __s2, size_t __n)
343:      __THROW;
344: #endif
345: 
346: 
347: __BEGIN_NAMESPACE_STD
348: /* Determine whether C constitutes a valid (one-byte) multibyte
349:    character.  */
350: extern wint_t btowc (int __c) __THROW;
351: 
352: /* Determine whether C corresponds to a member of the extended
353:    character set whose multibyte representation is a single byte.  */
354: extern int wctob (wint_t __c) __THROW;
355: 
356: /* Determine whether PS points to an object representing the initial
357:    state.  */
358: extern int mbsinit (__const mbstate_t *__ps) __THROW __attribute_pure__;
359: 
360: /* Write wide character representation of multibyte character pointed
361:    to by S to PWC.  */
362: extern size_t mbrtowc (wchar_t *__restrict __pwc,
363:                        __const char *__restrict __s, size_t __n,
364:                        mbstate_t *__p) __THROW;
365: 
366: /* Write multibyte representation of wide character WC to S.  */
367: extern size_t wcrtomb (char *__restrict __s, wchar_t __wc,
368:                        mbstate_t *__restrict __ps) __THROW;
369: 
370: /* Return number of bytes in multibyte character pointed to by S.  */
371: extern size_t __mbrlen (__const char *__restrict __s, size_t __n,
372:                         mbstate_t *__restrict __ps) __THROW;
373: extern size_t mbrlen (__const char *__restrict __s, size_t __n,
374:                       mbstate_t *__restrict __ps) __THROW;
375: __END_NAMESPACE_STD
376: 
377: #ifdef __USE_EXTERN_INLINES
378: /* Define inline function as optimization.  */
379: 
380: /* We can use the BTOWC and WCTOB optimizations since we know that all
381:    locales must use ASCII encoding for the values in the ASCII range
382:    and because the wchar_t encoding is always ISO 10646.  */
383: extern wint_t __btowc_alias (int __c) __asm ("btowc");
384: __extern_inline wint_t
385: __NTH (btowc (int __c))
386: { return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f'
387:           ? (wint_t) __c : __btowc_alias (__c)); }
388: 
389: extern int __wctob_alias (wint_t __c) __asm ("wctob");
390: __extern_inline int
391: __NTH (wctob (wint_t __wc))
392: { return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f'
393:           ? (int) __wc : __wctob_alias (__wc)); }
394: 
395: __extern_inline size_t
396: __NTH (mbrlen (__const char *__restrict __s, size_t __n,
397:                mbstate_t *__restrict __ps))
398: { return (__ps != NULL
399:           ? mbrtowc (NULL, __s, __n, __ps) : __mbrlen (__s, __n, NULL)); }
400: #endif
401: 
402: __BEGIN_NAMESPACE_STD
403: /* Write wide character representation of multibyte character string
404:    SRC to DST.  */
405: extern size_t mbsrtowcs (wchar_t *__restrict __dst,
406:                          __const char **__restrict __src, size_t __len,
407:                          mbstate_t *__restrict __ps) __THROW;
408: 
409: /* Write multibyte character representation of wide character string
410:    SRC to DST.  */
411: extern size_t wcsrtombs (char *__restrict __dst,
412:                          __const wchar_t **__restrict __src, size_t __len,
413:                          mbstate_t *__restrict __ps) __THROW;
414: __END_NAMESPACE_STD
415: 
416: 
417: #ifdef  __USE_XOPEN2K8
418: /* Write wide character representation of at most NMC bytes of the
419:    multibyte character string SRC to DST.  */
420: extern size_t mbsnrtowcs (wchar_t *__restrict __dst,
421:                           __const char **__restrict __src, size_t __nmc,
422:                           size_t __len, mbstate_t *__restrict __ps) __THROW;
423: 
424: /* Write multibyte character representation of at most NWC characters
425:    from the wide character string SRC to DST.  */
426: extern size_t wcsnrtombs (char *__restrict __dst,
427:                           __const wchar_t **__restrict __src,
428:                           size_t __nwc, size_t __len,
429:                           mbstate_t *__restrict __ps) __THROW;
430: #endif  /* use POSIX 2008 */
431: 
432: 
433: /* The following functions are extensions found in X/Open CAE.  */
434: #ifdef __USE_XOPEN
435: /* Determine number of column positions required for C.  */
436: extern int wcwidth (wchar_t __c) __THROW;
437: 
438: /* Determine number of column positions required for first N wide
439:    characters (or fewer if S ends before this) in S.  */
440: extern int wcswidth (__const wchar_t *__s, size_t __n) __THROW;
441: #endif  /* Use X/Open.  */
442: 
443: 
444: __BEGIN_NAMESPACE_STD
445: /* Convert initial portion of the wide string NPTR to `double'
446:    representation.  */
447: extern double wcstod (__const wchar_t *__restrict __nptr,
448:                       wchar_t **__restrict __endptr) __THROW;
449: __END_NAMESPACE_STD
450: 
451: #ifdef __USE_ISOC99
452: __BEGIN_NAMESPACE_C99
453: /* Likewise for `float' and `long double' sizes of floating-point numbers.  */
454: extern float wcstof (__const wchar_t *__restrict __nptr,
455:                      wchar_t **__restrict __endptr) __THROW;
456: extern long double wcstold (__const wchar_t *__restrict __nptr,
457:                             wchar_t **__restrict __endptr) __THROW;
458: __END_NAMESPACE_C99
459: #endif /* C99 */
460: 
461: 
462: __BEGIN_NAMESPACE_STD
463: /* Convert initial portion of wide string NPTR to `long int'
464:    representation.  */
465: extern long int wcstol (__const wchar_t *__restrict __nptr,
466:                         wchar_t **__restrict __endptr, int __base) __THROW;
467: 
468: /* Convert initial portion of wide string NPTR to `unsigned long int'
469:    representation.  */
470: extern unsigned long int wcstoul (__const wchar_t *__restrict __nptr,
471:                                   wchar_t **__restrict __endptr, int __base)
472:      __THROW;
473: __END_NAMESPACE_STD
474: 
475: #if defined __USE_ISOC99 || (defined __GNUC__ && defined __USE_GNU)
476: __BEGIN_NAMESPACE_C99
477: /* Convert initial portion of wide string NPTR to `long long int'
478:    representation.  */
479: __extension__
480: extern long long int wcstoll (__const wchar_t *__restrict __nptr,
481:                               wchar_t **__restrict __endptr, int __base)
482:      __THROW;
483: 
484: /* Convert initial portion of wide string NPTR to `unsigned long long int'
485:    representation.  */
486: __extension__
487: extern unsigned long long int wcstoull (__const wchar_t *__restrict __nptr,
488:                                         wchar_t **__restrict __endptr,
489:                                         int __base) __THROW;
490: __END_NAMESPACE_C99
491: #endif /* ISO C99 or GCC and GNU.  */
492: 
493: #if defined __GNUC__ && defined __USE_GNU
494: /* Convert initial portion of wide string NPTR to `long long int'
495:    representation.  */
496: __extension__
497: extern long long int wcstoq (__const wchar_t *__restrict __nptr,
498:                              wchar_t **__restrict __endptr, int __base)
499:      __THROW;
500: 
501: /* Convert initial portion of wide string NPTR to `unsigned long long int'
502:    representation.  */
503: __extension__
504: extern unsigned long long int wcstouq (__const wchar_t *__restrict __nptr,
505:                                        wchar_t **__restrict __endptr,
506:                                        int __base) __THROW;
507: #endif /* GCC and use GNU.  */
508: 
509: #ifdef __USE_GNU
510: /* The concept of one static locale per category is not very well
511:    thought out.  Many applications will need to process its data using
512:    information from several different locales.  Another application is
513:    the implementation of the internationalization handling in the
514:    upcoming ISO C++ standard library.  To support this another set of
515:    the functions using locale data exist which have an additional
516:    argument.
517: 
518:    Attention: all these functions are *not* standardized in any form.
519:    This is a proof-of-concept implementation.  */
520: 
521: /* Structure for reentrant locale using functions.  This is an
522:    (almost) opaque type for the user level programs.  */
523: # include <xlocale.h>
524: 
525: /* Special versions of the functions above which take the locale to
526:    use as an additional parameter.  */
527: extern long int wcstol_l (__const wchar_t *__restrict __nptr,
528:                           wchar_t **__restrict __endptr, int __base,
529:                           __locale_t __loc) __THROW;
530: 
531: extern unsigned long int wcstoul_l (__const wchar_t *__restrict __nptr,
532:                                     wchar_t **__restrict __endptr,
533:                                     int __base, __locale_t __loc) __THROW;
534: 
535: __extension__
536: extern long long int wcstoll_l (__const wchar_t *__restrict __nptr,
537:                                 wchar_t **__restrict __endptr,
538:                                 int __base, __locale_t __loc) __THROW;
539: 
540: __extension__
541: extern unsigned long long int wcstoull_l (__const wchar_t *__restrict __nptr,
542:                                           wchar_t **__restrict __endptr,
543:                                           int __base, __locale_t __loc)
544:      __THROW;
545: 
546: extern double wcstod_l (__const wchar_t *__restrict __nptr,
547:                         wchar_t **__restrict __endptr, __locale_t __loc)
548:      __THROW;
549: 
550: extern float wcstof_l (__const wchar_t *__restrict __nptr,
551:                        wchar_t **__restrict __endptr, __locale_t __loc)
552:      __THROW;
553: 
554: extern long double wcstold_l (__const wchar_t *__restrict __nptr,
555:                               wchar_t **__restrict __endptr,
556:                               __locale_t __loc) __THROW;
557: #endif  /* use GNU */
558: 
559: 
560: #ifdef __USE_XOPEN2K8
561: /* Copy SRC to DEST, returning the address of the terminating L'\0' in
562:    DEST.  */
563: extern wchar_t *wcpcpy (wchar_t *__restrict __dest,
564:                         __const wchar_t *__restrict __src) __THROW;
565: 
566: /* Copy no more than N characters of SRC to DEST, returning the address of
567:    the last character written into DEST.  */
568: extern wchar_t *wcpncpy (wchar_t *__restrict __dest,
569:                          __const wchar_t *__restrict __src, size_t __n)
570:      __THROW;
571: 
572: 
573: /* Wide character I/O functions.  */
574: 
575: /* Like OPEN_MEMSTREAM, but the stream is wide oriented and produces
576:    a wide character string.  */
577: extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) __THROW;
578: #endif
579: 
580: #if defined __USE_ISOC95 || defined __USE_UNIX98
581: __BEGIN_NAMESPACE_STD
582: 
583: /* Select orientation for stream.  */
584: extern int fwide (__FILE *__fp, int __mode) __THROW;
585: 
586: 
587: /* Write formatted output to STREAM.
588: 
589:    This function is a possible cancellation point and therefore not
590:    marked with __THROW.  */
591: extern int fwprintf (__FILE *__restrict __stream,
592:                      __const wchar_t *__restrict __format, ...)
593:      /* __attribute__ ((__format__ (__wprintf__, 2, 3))) */;
594: /* Write formatted output to stdout.
595: 
596:    This function is a possible cancellation point and therefore not
597:    marked with __THROW.  */
598: extern int wprintf (__const wchar_t *__restrict __format, ...)
599:      /* __attribute__ ((__format__ (__wprintf__, 1, 2))) */;
600: /* Write formatted output of at most N characters to S.  */
601: extern int swprintf (wchar_t *__restrict __s, size_t __n,
602:                      __const wchar_t *__restrict __format, ...)
603:      __THROW /* __attribute__ ((__format__ (__wprintf__, 3, 4))) */;
604: 
605: /* Write formatted output to S from argument list ARG.
606: 
607:    This function is a possible cancellation point and therefore not
608:    marked with __THROW.  */
609: extern int vfwprintf (__FILE *__restrict __s,
610:                       __const wchar_t *__restrict __format,
611:                       __gnuc_va_list __arg)
612:      /* __attribute__ ((__format__ (__wprintf__, 2, 0))) */;
613: /* Write formatted output to stdout from argument list ARG.
614: 
615:    This function is a possible cancellation point and therefore not
616:    marked with __THROW.  */
617: extern int vwprintf (__const wchar_t *__restrict __format,
618:                      __gnuc_va_list __arg)
619:      /* __attribute__ ((__format__ (__wprintf__, 1, 0))) */;
620: /* Write formatted output of at most N character to S from argument
621:    list ARG.  */
622: extern int vswprintf (wchar_t *__restrict __s, size_t __n,
623:                       __const wchar_t *__restrict __format,
624:                       __gnuc_va_list __arg)
625:      __THROW /* __attribute__ ((__format__ (__wprintf__, 3, 0))) */;
626: 
627: 
628: /* Read formatted input from STREAM.
629: 
630:    This function is a possible cancellation point and therefore not
631:    marked with __THROW.  */
632: extern int fwscanf (__FILE *__restrict __stream,
633:                     __const wchar_t *__restrict __format, ...)
634:      /* __attribute__ ((__format__ (__wscanf__, 2, 3))) */;
635: /* Read formatted input from stdin.
636: 
637:    This function is a possible cancellation point and therefore not
638:    marked with __THROW.  */
639: extern int wscanf (__const wchar_t *__restrict __format, ...)
640:      /* __attribute__ ((__format__ (__wscanf__, 1, 2))) */;
641: /* Read formatted input from S.  */
642: extern int swscanf (__const wchar_t *__restrict __s,
643:                     __const wchar_t *__restrict __format, ...)
644:      __THROW /* __attribute__ ((__format__ (__wscanf__, 2, 3))) */;
645: 
646: # if defined __USE_ISOC99 && !defined __USE_GNU \
647:      && (!defined __LDBL_COMPAT || !defined __REDIRECT) \
648:      && (defined __STRICT_ANSI__ || defined __USE_XOPEN2K)
649: #  ifdef __REDIRECT
650: /* For strict ISO C99 or POSIX compliance disallow %as, %aS and %a[
651:    GNU extension which conflicts with valid %a followed by letter
652:    s, S or [.  */
653: extern int __REDIRECT (fwscanf, (__FILE *__restrict __stream,
654:                                  __const wchar_t *__restrict __format, ...),
655:                        __isoc99_fwscanf)
656:      /* __attribute__ ((__format__ (__wscanf__, 2, 3))) */;
657: extern int __REDIRECT (wscanf, (__const wchar_t *__restrict __format, ...),
658:                        __isoc99_wscanf)
659:      /* __attribute__ ((__format__ (__wscanf__, 1, 2))) */;
660: extern int __REDIRECT_NTH (swscanf, (__const wchar_t *__restrict __s,
661:                                      __const wchar_t *__restrict __format,
662:                                      ...), __isoc99_swscanf)
663:      /* __attribute__ ((__format__ (__wscanf__, 2, 3))) */;
664: #  else
665: extern int __isoc99_fwscanf (__FILE *__restrict __stream,
666:                              __const wchar_t *__restrict __format, ...);
667: extern int __isoc99_wscanf (__const wchar_t *__restrict __format, ...);
668: extern int __isoc99_swscanf (__const wchar_t *__restrict __s,
669:                              __const wchar_t *__restrict __format, ...)
670:      __THROW;
671: #   define fwscanf __isoc99_fwscanf
672: #   define wscanf __isoc99_wscanf
673: #   define swscanf __isoc99_swscanf
674: #  endif
675: # endif
676: 
677: __END_NAMESPACE_STD
678: #endif /* Use ISO C95, C99 and Unix98. */
679: 
680: #ifdef __USE_ISOC99
681: __BEGIN_NAMESPACE_C99
682: /* Read formatted input from S into argument list ARG.
683: 
684:    This function is a possible cancellation point and therefore not
685:    marked with __THROW.  */
686: extern int vfwscanf (__FILE *__restrict __s,
687:                      __const wchar_t *__restrict __format,
688:                      __gnuc_va_list __arg)
689:      /* __attribute__ ((__format__ (__wscanf__, 2, 0))) */;
690: /* Read formatted input from stdin into argument list ARG.
691: 
692:    This function is a possible cancellation point and therefore not
693:    marked with __THROW.  */
694: extern int vwscanf (__const wchar_t *__restrict __format,
695:                     __gnuc_va_list __arg)
696:      /* __attribute__ ((__format__ (__wscanf__, 1, 0))) */;
697: /* Read formatted input from S into argument list ARG.  */
698: extern int vswscanf (__const wchar_t *__restrict __s,
699:                      __const wchar_t *__restrict __format,
700:                      __gnuc_va_list __arg)
701:      __THROW /* __attribute__ ((__format__ (__wscanf__, 2, 0))) */;
702: 
703: # if !defined __USE_GNU \
704:      && (!defined __LDBL_COMPAT || !defined __REDIRECT) \
705:      && (defined __STRICT_ANSI__ || defined __USE_XOPEN2K)
706: #  ifdef __REDIRECT
707: extern int __REDIRECT (vfwscanf, (__FILE *__restrict __s,
708:                                   __const wchar_t *__restrict __format,
709:                                   __gnuc_va_list __arg), __isoc99_vfwscanf)
710:      /* __attribute__ ((__format__ (__wscanf__, 2, 0))) */;
711: extern int __REDIRECT (vwscanf, (__const wchar_t *__restrict __format,
712:                                  __gnuc_va_list __arg), __isoc99_vwscanf)
713:      /* __attribute__ ((__format__ (__wscanf__, 1, 0))) */;
714: extern int __REDIRECT_NTH (vswscanf, (__const wchar_t *__restrict __s,
715:                                       __const wchar_t *__restrict __format,
716:                                       __gnuc_va_list __arg), __isoc99_vswscanf)
717:      /* __attribute__ ((__format__ (__wscanf__, 2, 0))) */;
718: #  else
719: extern int __isoc99_vfwscanf (__FILE *__restrict __s,
720:                               __const wchar_t *__restrict __format,
721:                               __gnuc_va_list __arg);
722: extern int __isoc99_vwscanf (__const wchar_t *__restrict __format,
723:                              __gnuc_va_list __arg);
724: extern int __isoc99_vswscanf (__const wchar_t *__restrict __s,
725:                               __const wchar_t *__restrict __format,
726:                               __gnuc_va_list __arg) __THROW;
727: #   define vfwscanf __isoc99_vfwscanf
728: #   define vwscanf __isoc99_vwscanf
729: #   define vswscanf __isoc99_vswscanf
730: #  endif
731: # endif
732: 
733: __END_NAMESPACE_C99
734: #endif /* Use ISO C99. */
735: 
736: 
737: __BEGIN_NAMESPACE_STD
738: /* Read a character from STREAM.
739: 
740:    These functions are possible cancellation points and therefore not
741:    marked with __THROW.  */
742: extern wint_t fgetwc (__FILE *__stream);
743: extern wint_t getwc (__FILE *__stream);
744: 
745: /* Read a character from stdin.
746: 
747:    This function is a possible cancellation point and therefore not
748:    marked with __THROW.  */
749: extern wint_t getwchar (void);
750: 
751: 
752: /* Write a character to STREAM.
753: 
754:    These functions are possible cancellation points and therefore not
755:    marked with __THROW.  */
756: extern wint_t fputwc (wchar_t __wc, __FILE *__stream);
757: extern wint_t putwc (wchar_t __wc, __FILE *__stream);
758: 
759: /* Write a character to stdout.
760: 
761:    This function is a possible cancellation point and therefore not
762:    marked with __THROW.  */
763: extern wint_t putwchar (wchar_t __wc);
764: 
765: 
766: /* Get a newline-terminated wide character string of finite length
767:    from STREAM.
768: 
769:    This function is a possible cancellation point and therefore not
770:    marked with __THROW.  */
771: extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n,
772:                         __FILE *__restrict __stream);
773: 
774: /* Write a string to STREAM.
775: 
776:    This function is a possible cancellation point and therefore not
777:    marked with __THROW.  */
778: extern int fputws (__const wchar_t *__restrict __ws,
779:                    __FILE *__restrict __stream);
780: 
781: 
782: /* Push a character back onto the input buffer of STREAM.
783: 
784:    This function is a possible cancellation point and therefore not
785:    marked with __THROW.  */
786: extern wint_t ungetwc (wint_t __wc, __FILE *__stream);
787: __END_NAMESPACE_STD
788: 
789: 
790: #ifdef __USE_GNU
791: /* These are defined to be equivalent to the `char' functions defined
792:    in POSIX.1:1996.
793: 
794:    These functions are not part of POSIX and therefore no official
795:    cancellation point.  But due to similarity with an POSIX interface
796:    or due to the implementation they are cancellation points and
797:    therefore not marked with __THROW.  */
798: extern wint_t getwc_unlocked (__FILE *__stream);
799: extern wint_t getwchar_unlocked (void);
800: 
801: /* This is the wide character version of a GNU extension.
802: 
803:    This function is not part of POSIX and therefore no official
804:    cancellation point.  But due to similarity with an POSIX interface
805:    or due to the implementation it is a cancellation point and
806:    therefore not marked with __THROW.  */
807: extern wint_t fgetwc_unlocked (__FILE *__stream);
808: 
809: /* Faster version when locking is not necessary.
810: 
811:    This function is not part of POSIX and therefore no official
812:    cancellation point.  But due to similarity with an POSIX interface
813:    or due to the implementation it is a cancellation point and
814:    therefore not marked with __THROW.  */
815: extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream);
816: 
817: /* These are defined to be equivalent to the `char' functions defined
818:    in POSIX.1:1996.
819: 
820:    These functions are not part of POSIX and therefore no official
821:    cancellation point.  But due to similarity with an POSIX interface
822:    or due to the implementation they are cancellation points and
823:    therefore not marked with __THROW.  */
824: extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream);
825: extern wint_t putwchar_unlocked (wchar_t __wc);
826: 
827: 
828: /* This function does the same as `fgetws' but does not lock the stream.
829: 
830:    This function is not part of POSIX and therefore no official
831:    cancellation point.  But due to similarity with an POSIX interface
832:    or due to the implementation it is a cancellation point and
833:    therefore not marked with __THROW.  */
834: extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n,
835:                                  __FILE *__restrict __stream);
836: 
837: /* This function does the same as `fputws' but does not lock the stream.
838: 
839:    This function is not part of POSIX and therefore no official
840:    cancellation point.  But due to similarity with an POSIX interface
841:    or due to the implementation it is a cancellation point and
842:    therefore not marked with __THROW.  */
843: extern int fputws_unlocked (__const wchar_t *__restrict __ws,
844:                             __FILE *__restrict __stream);
845: #endif
846: 
847: 
848: __BEGIN_NAMESPACE_C99
849: /* Format TP into S according to FORMAT.
850:    Write no more than MAXSIZE wide characters and return the number
851:    of wide characters written, or 0 if it would exceed MAXSIZE.  */
852: extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize,
853:                         __const wchar_t *__restrict __format,
854:                         __const struct tm *__restrict __tp) __THROW;
855: __END_NAMESPACE_C99
856: 
857: # ifdef __USE_GNU
858: # include <xlocale.h>
859: 
860: /* Similar to `wcsftime' but takes the information from
861:    the provided locale and not the global locale.  */
862: extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize,
863:                           __const wchar_t *__restrict __format,
864:                           __const struct tm *__restrict __tp,
865:                           __locale_t __loc) __THROW;
866: # endif
867: 
868: /* The X/Open standard demands that most of the functions defined in
869:    the <wctype.h> header must also appear here.  This is probably
870:    because some X/Open members wrote their implementation before the
871:    ISO C standard was published and introduced the better solution.
872:    We have to provide these definitions for compliance reasons but we
873:    do this nonsense only if really necessary.  */
874: #if defined __USE_UNIX98 && !defined __USE_GNU
875: # define __need_iswxxx
876: # include <wctype.h>
877: #endif
878: 
879: /* Define some macros helping to catch buffer overflows.  */
880: #if __USE_FORTIFY_LEVEL > 0 && defined __extern_always_inline
881: # include <bits/wchar2.h>
882: #endif
883: 
884: #ifdef __LDBL_COMPAT
885: # include <bits/wchar-ldbl.h>
886: #endif
887: 
888: __END_DECLS
889: 
890: #endif  /* _WCHAR_H defined */
891: 
892: #endif /* wchar.h  */
893: 
894: /* Undefine all __need_* constants in case we are included to get those
895:    constants but the whole file was already read.  */
896: #undef __need_mbstate_t
897: #undef __need_wint_t
898: 


for client 18.204.214.205
© Andrew Scott 2006 - 2024,
All Rights Reserved
http://www.andrew-scott.uk/
Andrew Scott
http://www.andrew-scott.co.uk/