1/* DO NOT EDIT! GENERATED AUTOMATICALLY! */ 2/* A substitute for ISO C99 <wchar.h>, for platforms that have issues. 3 4 Copyright (C) 2007-2012 Free Software Foundation, Inc. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3, or (at your option) 9 any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, see <http://www.gnu.org/licenses/>. */ 18 19/* Written by Eric Blake. */ 20 21/* 22 * ISO C 99 <wchar.h> for platforms that have issues. 23 * <http://www.opengroup.org/susv3xbd/wchar.h.html> 24 * 25 * For now, this just ensures proper prerequisite inclusion order and 26 * the declaration of wcwidth(). 27 */ 28 29#if __GNUC__ >= 3 30#pragma GCC system_header 31#endif 32 33 34#if defined __need_mbstate_t || defined __need_wint_t || (defined __hpux && ((defined _INTTYPES_INCLUDED && !defined strtoimax) || defined _GL_JUST_INCLUDE_SYSTEM_WCHAR_H)) || defined _GL_ALREADY_INCLUDING_WCHAR_H 35/* Special invocation convention: 36 - Inside glibc and uClibc header files. 37 - On HP-UX 11.00 we have a sequence of nested includes 38 <wchar.h> -> <stdlib.h> -> <stdint.h>, and the latter includes <wchar.h>, 39 once indirectly <stdint.h> -> <sys/types.h> -> <inttypes.h> -> <wchar.h> 40 and once directly. In both situations 'wint_t' is not yet defined, 41 therefore we cannot provide the function overrides; instead include only 42 the system's <wchar.h>. 43 - On IRIX 6.5, similarly, we have an include <wchar.h> -> <wctype.h>, and 44 the latter includes <wchar.h>. But here, we have no way to detect whether 45 <wctype.h> is completely included or is still being included. */ 46 47#include_next <wchar.h> 48 49#else 50/* Normal invocation convention. */ 51 52#ifndef _GL_WCHAR_H 53 54#define _GL_ALREADY_INCLUDING_WCHAR_H 55 56#if 1 57# include <features.h> /* for __GLIBC__ */ 58#endif 59 60/* Tru64 with Desktop Toolkit C has a bug: <stdio.h> must be included before 61 <wchar.h>. 62 BSD/OS 4.0.1 has a bug: <stddef.h>, <stdio.h> and <time.h> must be 63 included before <wchar.h>. 64 In some builds of uClibc, <wchar.h> is nonexistent and wchar_t is defined 65 by <stddef.h>. 66 But avoid namespace pollution on glibc systems. */ 67#if !(defined __GLIBC__ && !defined __UCLIBC__) 68# include <stddef.h> 69#endif 70#ifndef __GLIBC__ 71# include <stdio.h> 72# include <time.h> 73#endif 74 75/* Include the original <wchar.h> if it exists. 76 Some builds of uClibc lack it. */ 77/* The include_next requires a split double-inclusion guard. */ 78#if 1 79# include_next <wchar.h> 80#endif 81 82#undef _GL_ALREADY_INCLUDING_WCHAR_H 83 84#ifndef _GL_WCHAR_H 85#define _GL_WCHAR_H 86 87/* The __attribute__ feature is available in gcc versions 2.5 and later. 88 The attribute __pure__ was added in gcc 2.96. */ 89#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96) 90# define _GL_ATTRIBUTE_PURE __attribute__ ((__pure__)) 91#else 92# define _GL_ATTRIBUTE_PURE /* empty */ 93#endif 94 95/* The definitions of _GL_FUNCDECL_RPL etc. are copied here. */ 96#ifndef _GL_CXXDEFS_H 97#define _GL_CXXDEFS_H 98 99/* The three most frequent use cases of these macros are: 100 101 * For providing a substitute for a function that is missing on some 102 platforms, but is declared and works fine on the platforms on which 103 it exists: 104 105 #if @GNULIB_FOO@ 106 # if !@HAVE_FOO@ 107 _GL_FUNCDECL_SYS (foo, ...); 108 # endif 109 _GL_CXXALIAS_SYS (foo, ...); 110 _GL_CXXALIASWARN (foo); 111 #elif defined GNULIB_POSIXCHECK 112 ... 113 #endif 114 115 * For providing a replacement for a function that exists on all platforms, 116 but is broken/insufficient and needs to be replaced on some platforms: 117 118 #if @GNULIB_FOO@ 119 # if @REPLACE_FOO@ 120 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 121 # undef foo 122 # define foo rpl_foo 123 # endif 124 _GL_FUNCDECL_RPL (foo, ...); 125 _GL_CXXALIAS_RPL (foo, ...); 126 # else 127 _GL_CXXALIAS_SYS (foo, ...); 128 # endif 129 _GL_CXXALIASWARN (foo); 130 #elif defined GNULIB_POSIXCHECK 131 ... 132 #endif 133 134 * For providing a replacement for a function that exists on some platforms 135 but is broken/insufficient and needs to be replaced on some of them and 136 is additionally either missing or undeclared on some other platforms: 137 138 #if @GNULIB_FOO@ 139 # if @REPLACE_FOO@ 140 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 141 # undef foo 142 # define foo rpl_foo 143 # endif 144 _GL_FUNCDECL_RPL (foo, ...); 145 _GL_CXXALIAS_RPL (foo, ...); 146 # else 147 # if !@HAVE_FOO@ or if !@HAVE_DECL_FOO@ 148 _GL_FUNCDECL_SYS (foo, ...); 149 # endif 150 _GL_CXXALIAS_SYS (foo, ...); 151 # endif 152 _GL_CXXALIASWARN (foo); 153 #elif defined GNULIB_POSIXCHECK 154 ... 155 #endif 156*/ 157 158/* _GL_EXTERN_C declaration; 159 performs the declaration with C linkage. */ 160#if defined __cplusplus 161# define _GL_EXTERN_C extern "C" 162#else 163# define _GL_EXTERN_C extern 164#endif 165 166/* _GL_FUNCDECL_RPL (func, rettype, parameters_and_attributes); 167 declares a replacement function, named rpl_func, with the given prototype, 168 consisting of return type, parameters, and attributes. 169 Example: 170 _GL_FUNCDECL_RPL (open, int, (const char *filename, int flags, ...) 171 _GL_ARG_NONNULL ((1))); 172 */ 173#define _GL_FUNCDECL_RPL(func,rettype,parameters_and_attributes) \ 174 _GL_FUNCDECL_RPL_1 (rpl_##func, rettype, parameters_and_attributes) 175#define _GL_FUNCDECL_RPL_1(rpl_func,rettype,parameters_and_attributes) \ 176 _GL_EXTERN_C rettype rpl_func parameters_and_attributes 177 178/* _GL_FUNCDECL_SYS (func, rettype, parameters_and_attributes); 179 declares the system function, named func, with the given prototype, 180 consisting of return type, parameters, and attributes. 181 Example: 182 _GL_FUNCDECL_SYS (open, int, (const char *filename, int flags, ...) 183 _GL_ARG_NONNULL ((1))); 184 */ 185#define _GL_FUNCDECL_SYS(func,rettype,parameters_and_attributes) \ 186 _GL_EXTERN_C rettype func parameters_and_attributes 187 188/* _GL_CXXALIAS_RPL (func, rettype, parameters); 189 declares a C++ alias called GNULIB_NAMESPACE::func 190 that redirects to rpl_func, if GNULIB_NAMESPACE is defined. 191 Example: 192 _GL_CXXALIAS_RPL (open, int, (const char *filename, int flags, ...)); 193 */ 194#define _GL_CXXALIAS_RPL(func,rettype,parameters) \ 195 _GL_CXXALIAS_RPL_1 (func, rpl_##func, rettype, parameters) 196#if defined __cplusplus && defined GNULIB_NAMESPACE 197# define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \ 198 namespace GNULIB_NAMESPACE \ 199 { \ 200 rettype (*const func) parameters = ::rpl_func; \ 201 } \ 202 _GL_EXTERN_C int _gl_cxxalias_dummy 203#else 204# define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \ 205 _GL_EXTERN_C int _gl_cxxalias_dummy 206#endif 207 208/* _GL_CXXALIAS_RPL_CAST_1 (func, rpl_func, rettype, parameters); 209 is like _GL_CXXALIAS_RPL_1 (func, rpl_func, rettype, parameters); 210 except that the C function rpl_func may have a slightly different 211 declaration. A cast is used to silence the "invalid conversion" error 212 that would otherwise occur. */ 213#if defined __cplusplus && defined GNULIB_NAMESPACE 214# define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \ 215 namespace GNULIB_NAMESPACE \ 216 { \ 217 rettype (*const func) parameters = \ 218 reinterpret_cast<rettype(*)parameters>(::rpl_func); \ 219 } \ 220 _GL_EXTERN_C int _gl_cxxalias_dummy 221#else 222# define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \ 223 _GL_EXTERN_C int _gl_cxxalias_dummy 224#endif 225 226/* _GL_CXXALIAS_SYS (func, rettype, parameters); 227 declares a C++ alias called GNULIB_NAMESPACE::func 228 that redirects to the system provided function func, if GNULIB_NAMESPACE 229 is defined. 230 Example: 231 _GL_CXXALIAS_SYS (open, int, (const char *filename, int flags, ...)); 232 */ 233#if defined __cplusplus && defined GNULIB_NAMESPACE 234 /* If we were to write 235 rettype (*const func) parameters = ::func; 236 like above in _GL_CXXALIAS_RPL_1, the compiler could optimize calls 237 better (remove an indirection through a 'static' pointer variable), 238 but then the _GL_CXXALIASWARN macro below would cause a warning not only 239 for uses of ::func but also for uses of GNULIB_NAMESPACE::func. */ 240# define _GL_CXXALIAS_SYS(func,rettype,parameters) \ 241 namespace GNULIB_NAMESPACE \ 242 { \ 243 static rettype (*func) parameters = ::func; \ 244 } \ 245 _GL_EXTERN_C int _gl_cxxalias_dummy 246#else 247# define _GL_CXXALIAS_SYS(func,rettype,parameters) \ 248 _GL_EXTERN_C int _gl_cxxalias_dummy 249#endif 250 251/* _GL_CXXALIAS_SYS_CAST (func, rettype, parameters); 252 is like _GL_CXXALIAS_SYS (func, rettype, parameters); 253 except that the C function func may have a slightly different declaration. 254 A cast is used to silence the "invalid conversion" error that would 255 otherwise occur. */ 256#if defined __cplusplus && defined GNULIB_NAMESPACE 257# define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \ 258 namespace GNULIB_NAMESPACE \ 259 { \ 260 static rettype (*func) parameters = \ 261 reinterpret_cast<rettype(*)parameters>(::func); \ 262 } \ 263 _GL_EXTERN_C int _gl_cxxalias_dummy 264#else 265# define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \ 266 _GL_EXTERN_C int _gl_cxxalias_dummy 267#endif 268 269/* _GL_CXXALIAS_SYS_CAST2 (func, rettype, parameters, rettype2, parameters2); 270 is like _GL_CXXALIAS_SYS (func, rettype, parameters); 271 except that the C function is picked among a set of overloaded functions, 272 namely the one with rettype2 and parameters2. Two consecutive casts 273 are used to silence the "cannot find a match" and "invalid conversion" 274 errors that would otherwise occur. */ 275#if defined __cplusplus && defined GNULIB_NAMESPACE 276 /* The outer cast must be a reinterpret_cast. 277 The inner cast: When the function is defined as a set of overloaded 278 functions, it works as a static_cast<>, choosing the designated variant. 279 When the function is defined as a single variant, it works as a 280 reinterpret_cast<>. The parenthesized cast syntax works both ways. */ 281# define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \ 282 namespace GNULIB_NAMESPACE \ 283 { \ 284 static rettype (*func) parameters = \ 285 reinterpret_cast<rettype(*)parameters>( \ 286 (rettype2(*)parameters2)(::func)); \ 287 } \ 288 _GL_EXTERN_C int _gl_cxxalias_dummy 289#else 290# define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \ 291 _GL_EXTERN_C int _gl_cxxalias_dummy 292#endif 293 294/* _GL_CXXALIASWARN (func); 295 causes a warning to be emitted when ::func is used but not when 296 GNULIB_NAMESPACE::func is used. func must be defined without overloaded 297 variants. */ 298#if defined __cplusplus && defined GNULIB_NAMESPACE 299# define _GL_CXXALIASWARN(func) \ 300 _GL_CXXALIASWARN_1 (func, GNULIB_NAMESPACE) 301# define _GL_CXXALIASWARN_1(func,namespace) \ 302 _GL_CXXALIASWARN_2 (func, namespace) 303/* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>, 304 we enable the warning only when not optimizing. */ 305# if !__OPTIMIZE__ 306# define _GL_CXXALIASWARN_2(func,namespace) \ 307 _GL_WARN_ON_USE (func, \ 308 "The symbol ::" #func " refers to the system function. " \ 309 "Use " #namespace "::" #func " instead.") 310# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 311# define _GL_CXXALIASWARN_2(func,namespace) \ 312 extern __typeof__ (func) func 313# else 314# define _GL_CXXALIASWARN_2(func,namespace) \ 315 _GL_EXTERN_C int _gl_cxxalias_dummy 316# endif 317#else 318# define _GL_CXXALIASWARN(func) \ 319 _GL_EXTERN_C int _gl_cxxalias_dummy 320#endif 321 322/* _GL_CXXALIASWARN1 (func, rettype, parameters_and_attributes); 323 causes a warning to be emitted when the given overloaded variant of ::func 324 is used but not when GNULIB_NAMESPACE::func is used. */ 325#if defined __cplusplus && defined GNULIB_NAMESPACE 326# define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \ 327 _GL_CXXALIASWARN1_1 (func, rettype, parameters_and_attributes, \ 328 GNULIB_NAMESPACE) 329# define _GL_CXXALIASWARN1_1(func,rettype,parameters_and_attributes,namespace) \ 330 _GL_CXXALIASWARN1_2 (func, rettype, parameters_and_attributes, namespace) 331/* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>, 332 we enable the warning only when not optimizing. */ 333# if !__OPTIMIZE__ 334# define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \ 335 _GL_WARN_ON_USE_CXX (func, rettype, parameters_and_attributes, \ 336 "The symbol ::" #func " refers to the system function. " \ 337 "Use " #namespace "::" #func " instead.") 338# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 339# define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \ 340 extern __typeof__ (func) func 341# else 342# define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \ 343 _GL_EXTERN_C int _gl_cxxalias_dummy 344# endif 345#else 346# define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \ 347 _GL_EXTERN_C int _gl_cxxalias_dummy 348#endif 349 350#endif /* _GL_CXXDEFS_H */ 351 352/* The definition of _GL_ARG_NONNULL is copied here. */ 353/* _GL_ARG_NONNULL((n,...,m)) tells the compiler and static analyzer tools 354 that the values passed as arguments n, ..., m must be non-NULL pointers. 355 n = 1 stands for the first argument, n = 2 for the second argument etc. */ 356#ifndef _GL_ARG_NONNULL 357# if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || __GNUC__ > 3 358# define _GL_ARG_NONNULL(params) __attribute__ ((__nonnull__ params)) 359# else 360# define _GL_ARG_NONNULL(params) 361# endif 362#endif 363 364/* The definition of _GL_WARN_ON_USE is copied here. */ 365#ifndef _GL_WARN_ON_USE 366 367# if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__) 368/* A compiler attribute is available in gcc versions 4.3.0 and later. */ 369# define _GL_WARN_ON_USE(function, message) \ 370extern __typeof__ (function) function __attribute__ ((__warning__ (message))) 371# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 372/* Verify the existence of the function. */ 373# define _GL_WARN_ON_USE(function, message) \ 374extern __typeof__ (function) function 375# else /* Unsupported. */ 376# define _GL_WARN_ON_USE(function, message) \ 377_GL_WARN_EXTERN_C int _gl_warn_on_use 378# endif 379#endif 380 381/* _GL_WARN_ON_USE_CXX (function, rettype, parameters_and_attributes, "string") 382 is like _GL_WARN_ON_USE (function, "string"), except that the function is 383 declared with the given prototype, consisting of return type, parameters, 384 and attributes. 385 This variant is useful for overloaded functions in C++. _GL_WARN_ON_USE does 386 not work in this case. */ 387#ifndef _GL_WARN_ON_USE_CXX 388# if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__) 389# define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \ 390extern rettype function parameters_and_attributes \ 391 __attribute__ ((__warning__ (msg))) 392# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 393/* Verify the existence of the function. */ 394# define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \ 395extern rettype function parameters_and_attributes 396# else /* Unsupported. */ 397# define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \ 398_GL_WARN_EXTERN_C int _gl_warn_on_use 399# endif 400#endif 401 402/* _GL_WARN_EXTERN_C declaration; 403 performs the declaration with C linkage. */ 404#ifndef _GL_WARN_EXTERN_C 405# if defined __cplusplus 406# define _GL_WARN_EXTERN_C extern "C" 407# else 408# define _GL_WARN_EXTERN_C extern 409# endif 410#endif 411 412 413/* Define wint_t and WEOF. (Also done in wctype.in.h.) */ 414#if !1 && !defined wint_t 415# define wint_t int 416# ifndef WEOF 417# define WEOF -1 418# endif 419#else 420/* MSVC defines wint_t as 'unsigned short' in <crtdefs.h>. 421 This is too small: ISO C 99 section 7.24.1.(2) says that wint_t must be 422 "unchanged by default argument promotions". Override it. */ 423# if defined _MSC_VER 424# if !GNULIB_defined_wint_t 425# include <crtdefs.h> 426typedef unsigned int rpl_wint_t; 427# undef wint_t 428# define wint_t rpl_wint_t 429# define GNULIB_defined_wint_t 1 430# endif 431# endif 432# ifndef WEOF 433# define WEOF ((wint_t) -1) 434# endif 435#endif 436 437 438/* Override mbstate_t if it is too small. 439 On IRIX 6.5, sizeof (mbstate_t) == 1, which is not sufficient for 440 implementing mbrtowc for encodings like UTF-8. */ 441#if !(1 && 1) || 0 442# if !GNULIB_defined_mbstate_t 443typedef int rpl_mbstate_t; 444# undef mbstate_t 445# define mbstate_t rpl_mbstate_t 446# define GNULIB_defined_mbstate_t 1 447# endif 448#endif 449 450 451/* Convert a single-byte character to a wide character. */ 452#if 0 453# if 0 454# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 455# undef btowc 456# define btowc rpl_btowc 457# endif 458_GL_FUNCDECL_RPL (btowc, wint_t, (int c) _GL_ATTRIBUTE_PURE); 459_GL_CXXALIAS_RPL (btowc, wint_t, (int c)); 460# else 461# if !1 462_GL_FUNCDECL_SYS (btowc, wint_t, (int c) _GL_ATTRIBUTE_PURE); 463# endif 464_GL_CXXALIAS_SYS (btowc, wint_t, (int c)); 465# endif 466_GL_CXXALIASWARN (btowc); 467#elif defined GNULIB_POSIXCHECK 468# undef btowc 469# if HAVE_RAW_DECL_BTOWC 470_GL_WARN_ON_USE (btowc, "btowc is unportable - " 471 "use gnulib module btowc for portability"); 472# endif 473#endif 474 475 476/* Convert a wide character to a single-byte character. */ 477#if 0 478# if 0 479# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 480# undef wctob 481# define wctob rpl_wctob 482# endif 483_GL_FUNCDECL_RPL (wctob, int, (wint_t wc) _GL_ATTRIBUTE_PURE); 484_GL_CXXALIAS_RPL (wctob, int, (wint_t wc)); 485# else 486# if !defined wctob && !1 487/* wctob is provided by gnulib, or wctob exists but is not declared. */ 488_GL_FUNCDECL_SYS (wctob, int, (wint_t wc) _GL_ATTRIBUTE_PURE); 489# endif 490_GL_CXXALIAS_SYS (wctob, int, (wint_t wc)); 491# endif 492_GL_CXXALIASWARN (wctob); 493#elif defined GNULIB_POSIXCHECK 494# undef wctob 495# if HAVE_RAW_DECL_WCTOB 496_GL_WARN_ON_USE (wctob, "wctob is unportable - " 497 "use gnulib module wctob for portability"); 498# endif 499#endif 500 501 502/* Test whether *PS is in the initial state. */ 503#if 1 504# if 0 505# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 506# undef mbsinit 507# define mbsinit rpl_mbsinit 508# endif 509_GL_FUNCDECL_RPL (mbsinit, int, (const mbstate_t *ps)); 510_GL_CXXALIAS_RPL (mbsinit, int, (const mbstate_t *ps)); 511# else 512# if !1 513_GL_FUNCDECL_SYS (mbsinit, int, (const mbstate_t *ps)); 514# endif 515_GL_CXXALIAS_SYS (mbsinit, int, (const mbstate_t *ps)); 516# endif 517_GL_CXXALIASWARN (mbsinit); 518#elif defined GNULIB_POSIXCHECK 519# undef mbsinit 520# if HAVE_RAW_DECL_MBSINIT 521_GL_WARN_ON_USE (mbsinit, "mbsinit is unportable - " 522 "use gnulib module mbsinit for portability"); 523# endif 524#endif 525 526 527/* Convert a multibyte character to a wide character. */ 528#if 1 529# if 0 530# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 531# undef mbrtowc 532# define mbrtowc rpl_mbrtowc 533# endif 534_GL_FUNCDECL_RPL (mbrtowc, size_t, 535 (wchar_t *pwc, const char *s, size_t n, mbstate_t *ps)); 536_GL_CXXALIAS_RPL (mbrtowc, size_t, 537 (wchar_t *pwc, const char *s, size_t n, mbstate_t *ps)); 538# else 539# if !1 540_GL_FUNCDECL_SYS (mbrtowc, size_t, 541 (wchar_t *pwc, const char *s, size_t n, mbstate_t *ps)); 542# endif 543_GL_CXXALIAS_SYS (mbrtowc, size_t, 544 (wchar_t *pwc, const char *s, size_t n, mbstate_t *ps)); 545# endif 546_GL_CXXALIASWARN (mbrtowc); 547#elif defined GNULIB_POSIXCHECK 548# undef mbrtowc 549# if HAVE_RAW_DECL_MBRTOWC 550_GL_WARN_ON_USE (mbrtowc, "mbrtowc is unportable - " 551 "use gnulib module mbrtowc for portability"); 552# endif 553#endif 554 555 556/* Recognize a multibyte character. */ 557#if 0 558# if 0 559# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 560# undef mbrlen 561# define mbrlen rpl_mbrlen 562# endif 563_GL_FUNCDECL_RPL (mbrlen, size_t, (const char *s, size_t n, mbstate_t *ps)); 564_GL_CXXALIAS_RPL (mbrlen, size_t, (const char *s, size_t n, mbstate_t *ps)); 565# else 566# if !1 567_GL_FUNCDECL_SYS (mbrlen, size_t, (const char *s, size_t n, mbstate_t *ps)); 568# endif 569_GL_CXXALIAS_SYS (mbrlen, size_t, (const char *s, size_t n, mbstate_t *ps)); 570# endif 571_GL_CXXALIASWARN (mbrlen); 572#elif defined GNULIB_POSIXCHECK 573# undef mbrlen 574# if HAVE_RAW_DECL_MBRLEN 575_GL_WARN_ON_USE (mbrlen, "mbrlen is unportable - " 576 "use gnulib module mbrlen for portability"); 577# endif 578#endif 579 580 581/* Convert a string to a wide string. */ 582#if 0 583# if 0 584# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 585# undef mbsrtowcs 586# define mbsrtowcs rpl_mbsrtowcs 587# endif 588_GL_FUNCDECL_RPL (mbsrtowcs, size_t, 589 (wchar_t *dest, const char **srcp, size_t len, mbstate_t *ps) 590 _GL_ARG_NONNULL ((2))); 591_GL_CXXALIAS_RPL (mbsrtowcs, size_t, 592 (wchar_t *dest, const char **srcp, size_t len, 593 mbstate_t *ps)); 594# else 595# if !1 596_GL_FUNCDECL_SYS (mbsrtowcs, size_t, 597 (wchar_t *dest, const char **srcp, size_t len, mbstate_t *ps) 598 _GL_ARG_NONNULL ((2))); 599# endif 600_GL_CXXALIAS_SYS (mbsrtowcs, size_t, 601 (wchar_t *dest, const char **srcp, size_t len, 602 mbstate_t *ps)); 603# endif 604_GL_CXXALIASWARN (mbsrtowcs); 605#elif defined GNULIB_POSIXCHECK 606# undef mbsrtowcs 607# if HAVE_RAW_DECL_MBSRTOWCS 608_GL_WARN_ON_USE (mbsrtowcs, "mbsrtowcs is unportable - " 609 "use gnulib module mbsrtowcs for portability"); 610# endif 611#endif 612 613 614/* Convert a string to a wide string. */ 615#if 0 616# if 0 617# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 618# undef mbsnrtowcs 619# define mbsnrtowcs rpl_mbsnrtowcs 620# endif 621_GL_FUNCDECL_RPL (mbsnrtowcs, size_t, 622 (wchar_t *dest, const char **srcp, size_t srclen, size_t len, 623 mbstate_t *ps) 624 _GL_ARG_NONNULL ((2))); 625_GL_CXXALIAS_RPL (mbsnrtowcs, size_t, 626 (wchar_t *dest, const char **srcp, size_t srclen, size_t len, 627 mbstate_t *ps)); 628# else 629# if !1 630_GL_FUNCDECL_SYS (mbsnrtowcs, size_t, 631 (wchar_t *dest, const char **srcp, size_t srclen, size_t len, 632 mbstate_t *ps) 633 _GL_ARG_NONNULL ((2))); 634# endif 635_GL_CXXALIAS_SYS (mbsnrtowcs, size_t, 636 (wchar_t *dest, const char **srcp, size_t srclen, size_t len, 637 mbstate_t *ps)); 638# endif 639_GL_CXXALIASWARN (mbsnrtowcs); 640#elif defined GNULIB_POSIXCHECK 641# undef mbsnrtowcs 642# if HAVE_RAW_DECL_MBSNRTOWCS 643_GL_WARN_ON_USE (mbsnrtowcs, "mbsnrtowcs is unportable - " 644 "use gnulib module mbsnrtowcs for portability"); 645# endif 646#endif 647 648 649/* Convert a wide character to a multibyte character. */ 650#if 0 651# if 0 652# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 653# undef wcrtomb 654# define wcrtomb rpl_wcrtomb 655# endif 656_GL_FUNCDECL_RPL (wcrtomb, size_t, (char *s, wchar_t wc, mbstate_t *ps)); 657_GL_CXXALIAS_RPL (wcrtomb, size_t, (char *s, wchar_t wc, mbstate_t *ps)); 658# else 659# if !1 660_GL_FUNCDECL_SYS (wcrtomb, size_t, (char *s, wchar_t wc, mbstate_t *ps)); 661# endif 662_GL_CXXALIAS_SYS (wcrtomb, size_t, (char *s, wchar_t wc, mbstate_t *ps)); 663# endif 664_GL_CXXALIASWARN (wcrtomb); 665#elif defined GNULIB_POSIXCHECK 666# undef wcrtomb 667# if HAVE_RAW_DECL_WCRTOMB 668_GL_WARN_ON_USE (wcrtomb, "wcrtomb is unportable - " 669 "use gnulib module wcrtomb for portability"); 670# endif 671#endif 672 673 674/* Convert a wide string to a string. */ 675#if 0 676# if 0 677# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 678# undef wcsrtombs 679# define wcsrtombs rpl_wcsrtombs 680# endif 681_GL_FUNCDECL_RPL (wcsrtombs, size_t, 682 (char *dest, const wchar_t **srcp, size_t len, mbstate_t *ps) 683 _GL_ARG_NONNULL ((2))); 684_GL_CXXALIAS_RPL (wcsrtombs, size_t, 685 (char *dest, const wchar_t **srcp, size_t len, 686 mbstate_t *ps)); 687# else 688# if !1 689_GL_FUNCDECL_SYS (wcsrtombs, size_t, 690 (char *dest, const wchar_t **srcp, size_t len, mbstate_t *ps) 691 _GL_ARG_NONNULL ((2))); 692# endif 693_GL_CXXALIAS_SYS (wcsrtombs, size_t, 694 (char *dest, const wchar_t **srcp, size_t len, 695 mbstate_t *ps)); 696# endif 697_GL_CXXALIASWARN (wcsrtombs); 698#elif defined GNULIB_POSIXCHECK 699# undef wcsrtombs 700# if HAVE_RAW_DECL_WCSRTOMBS 701_GL_WARN_ON_USE (wcsrtombs, "wcsrtombs is unportable - " 702 "use gnulib module wcsrtombs for portability"); 703# endif 704#endif 705 706 707/* Convert a wide string to a string. */ 708#if 0 709# if 0 710# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 711# undef wcsnrtombs 712# define wcsnrtombs rpl_wcsnrtombs 713# endif 714_GL_FUNCDECL_RPL (wcsnrtombs, size_t, 715 (char *dest, const wchar_t **srcp, size_t srclen, size_t len, 716 mbstate_t *ps) 717 _GL_ARG_NONNULL ((2))); 718_GL_CXXALIAS_RPL (wcsnrtombs, size_t, 719 (char *dest, const wchar_t **srcp, size_t srclen, size_t len, 720 mbstate_t *ps)); 721# else 722# if !1 723_GL_FUNCDECL_SYS (wcsnrtombs, size_t, 724 (char *dest, const wchar_t **srcp, size_t srclen, size_t len, 725 mbstate_t *ps) 726 _GL_ARG_NONNULL ((2))); 727# endif 728_GL_CXXALIAS_SYS (wcsnrtombs, size_t, 729 (char *dest, const wchar_t **srcp, size_t srclen, size_t len, 730 mbstate_t *ps)); 731# endif 732_GL_CXXALIASWARN (wcsnrtombs); 733#elif defined GNULIB_POSIXCHECK 734# undef wcsnrtombs 735# if HAVE_RAW_DECL_WCSNRTOMBS 736_GL_WARN_ON_USE (wcsnrtombs, "wcsnrtombs is unportable - " 737 "use gnulib module wcsnrtombs for portability"); 738# endif 739#endif 740 741 742/* Return the number of screen columns needed for WC. */ 743#if 1 744# if 0 745# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 746# undef wcwidth 747# define wcwidth rpl_wcwidth 748# endif 749_GL_FUNCDECL_RPL (wcwidth, int, (wchar_t) _GL_ATTRIBUTE_PURE); 750_GL_CXXALIAS_RPL (wcwidth, int, (wchar_t)); 751# else 752# if !1 753/* wcwidth exists but is not declared. */ 754_GL_FUNCDECL_SYS (wcwidth, int, (wchar_t) _GL_ATTRIBUTE_PURE); 755# endif 756_GL_CXXALIAS_SYS (wcwidth, int, (wchar_t)); 757# endif 758_GL_CXXALIASWARN (wcwidth); 759#elif defined GNULIB_POSIXCHECK 760# undef wcwidth 761# if HAVE_RAW_DECL_WCWIDTH 762_GL_WARN_ON_USE (wcwidth, "wcwidth is unportable - " 763 "use gnulib module wcwidth for portability"); 764# endif 765#endif 766 767 768/* Search N wide characters of S for C. */ 769#if 0 770# if !1 771_GL_FUNCDECL_SYS (wmemchr, wchar_t *, (const wchar_t *s, wchar_t c, size_t n) 772 _GL_ATTRIBUTE_PURE); 773# endif 774 /* On some systems, this function is defined as an overloaded function: 775 extern "C++" { 776 const wchar_t * std::wmemchr (const wchar_t *, wchar_t, size_t); 777 wchar_t * std::wmemchr (wchar_t *, wchar_t, size_t); 778 } */ 779_GL_CXXALIAS_SYS_CAST2 (wmemchr, 780 wchar_t *, (const wchar_t *, wchar_t, size_t), 781 const wchar_t *, (const wchar_t *, wchar_t, size_t)); 782# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \ 783 && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) 784_GL_CXXALIASWARN1 (wmemchr, wchar_t *, (wchar_t *s, wchar_t c, size_t n)); 785_GL_CXXALIASWARN1 (wmemchr, const wchar_t *, 786 (const wchar_t *s, wchar_t c, size_t n)); 787# else 788_GL_CXXALIASWARN (wmemchr); 789# endif 790#elif defined GNULIB_POSIXCHECK 791# undef wmemchr 792# if HAVE_RAW_DECL_WMEMCHR 793_GL_WARN_ON_USE (wmemchr, "wmemchr is unportable - " 794 "use gnulib module wmemchr for portability"); 795# endif 796#endif 797 798 799/* Compare N wide characters of S1 and S2. */ 800#if 0 801# if !1 802_GL_FUNCDECL_SYS (wmemcmp, int, 803 (const wchar_t *s1, const wchar_t *s2, size_t n) 804 _GL_ATTRIBUTE_PURE); 805# endif 806_GL_CXXALIAS_SYS (wmemcmp, int, 807 (const wchar_t *s1, const wchar_t *s2, size_t n)); 808_GL_CXXALIASWARN (wmemcmp); 809#elif defined GNULIB_POSIXCHECK 810# undef wmemcmp 811# if HAVE_RAW_DECL_WMEMCMP 812_GL_WARN_ON_USE (wmemcmp, "wmemcmp is unportable - " 813 "use gnulib module wmemcmp for portability"); 814# endif 815#endif 816 817 818/* Copy N wide characters of SRC to DEST. */ 819#if 0 820# if !1 821_GL_FUNCDECL_SYS (wmemcpy, wchar_t *, 822 (wchar_t *dest, const wchar_t *src, size_t n)); 823# endif 824_GL_CXXALIAS_SYS (wmemcpy, wchar_t *, 825 (wchar_t *dest, const wchar_t *src, size_t n)); 826_GL_CXXALIASWARN (wmemcpy); 827#elif defined GNULIB_POSIXCHECK 828# undef wmemcpy 829# if HAVE_RAW_DECL_WMEMCPY 830_GL_WARN_ON_USE (wmemcpy, "wmemcpy is unportable - " 831 "use gnulib module wmemcpy for portability"); 832# endif 833#endif 834 835 836/* Copy N wide characters of SRC to DEST, guaranteeing correct behavior for 837 overlapping memory areas. */ 838#if 0 839# if !1 840_GL_FUNCDECL_SYS (wmemmove, wchar_t *, 841 (wchar_t *dest, const wchar_t *src, size_t n)); 842# endif 843_GL_CXXALIAS_SYS (wmemmove, wchar_t *, 844 (wchar_t *dest, const wchar_t *src, size_t n)); 845_GL_CXXALIASWARN (wmemmove); 846#elif defined GNULIB_POSIXCHECK 847# undef wmemmove 848# if HAVE_RAW_DECL_WMEMMOVE 849_GL_WARN_ON_USE (wmemmove, "wmemmove is unportable - " 850 "use gnulib module wmemmove for portability"); 851# endif 852#endif 853 854 855/* Set N wide characters of S to C. */ 856#if 0 857# if !1 858_GL_FUNCDECL_SYS (wmemset, wchar_t *, (wchar_t *s, wchar_t c, size_t n)); 859# endif 860_GL_CXXALIAS_SYS (wmemset, wchar_t *, (wchar_t *s, wchar_t c, size_t n)); 861_GL_CXXALIASWARN (wmemset); 862#elif defined GNULIB_POSIXCHECK 863# undef wmemset 864# if HAVE_RAW_DECL_WMEMSET 865_GL_WARN_ON_USE (wmemset, "wmemset is unportable - " 866 "use gnulib module wmemset for portability"); 867# endif 868#endif 869 870 871/* Return the number of wide characters in S. */ 872#if 0 873# if !1 874_GL_FUNCDECL_SYS (wcslen, size_t, (const wchar_t *s) _GL_ATTRIBUTE_PURE); 875# endif 876_GL_CXXALIAS_SYS (wcslen, size_t, (const wchar_t *s)); 877_GL_CXXALIASWARN (wcslen); 878#elif defined GNULIB_POSIXCHECK 879# undef wcslen 880# if HAVE_RAW_DECL_WCSLEN 881_GL_WARN_ON_USE (wcslen, "wcslen is unportable - " 882 "use gnulib module wcslen for portability"); 883# endif 884#endif 885 886 887/* Return the number of wide characters in S, but at most MAXLEN. */ 888#if 0 889# if !1 890_GL_FUNCDECL_SYS (wcsnlen, size_t, (const wchar_t *s, size_t maxlen) 891 _GL_ATTRIBUTE_PURE); 892# endif 893_GL_CXXALIAS_SYS (wcsnlen, size_t, (const wchar_t *s, size_t maxlen)); 894_GL_CXXALIASWARN (wcsnlen); 895#elif defined GNULIB_POSIXCHECK 896# undef wcsnlen 897# if HAVE_RAW_DECL_WCSNLEN 898_GL_WARN_ON_USE (wcsnlen, "wcsnlen is unportable - " 899 "use gnulib module wcsnlen for portability"); 900# endif 901#endif 902 903 904/* Copy SRC to DEST. */ 905#if 0 906# if !1 907_GL_FUNCDECL_SYS (wcscpy, wchar_t *, (wchar_t *dest, const wchar_t *src)); 908# endif 909_GL_CXXALIAS_SYS (wcscpy, wchar_t *, (wchar_t *dest, const wchar_t *src)); 910_GL_CXXALIASWARN (wcscpy); 911#elif defined GNULIB_POSIXCHECK 912# undef wcscpy 913# if HAVE_RAW_DECL_WCSCPY 914_GL_WARN_ON_USE (wcscpy, "wcscpy is unportable - " 915 "use gnulib module wcscpy for portability"); 916# endif 917#endif 918 919 920/* Copy SRC to DEST, returning the address of the terminating L'\0' in DEST. */ 921#if 0 922# if !1 923_GL_FUNCDECL_SYS (wcpcpy, wchar_t *, (wchar_t *dest, const wchar_t *src)); 924# endif 925_GL_CXXALIAS_SYS (wcpcpy, wchar_t *, (wchar_t *dest, const wchar_t *src)); 926_GL_CXXALIASWARN (wcpcpy); 927#elif defined GNULIB_POSIXCHECK 928# undef wcpcpy 929# if HAVE_RAW_DECL_WCPCPY 930_GL_WARN_ON_USE (wcpcpy, "wcpcpy is unportable - " 931 "use gnulib module wcpcpy for portability"); 932# endif 933#endif 934 935 936/* Copy no more than N wide characters of SRC to DEST. */ 937#if 0 938# if !1 939_GL_FUNCDECL_SYS (wcsncpy, wchar_t *, 940 (wchar_t *dest, const wchar_t *src, size_t n)); 941# endif 942_GL_CXXALIAS_SYS (wcsncpy, wchar_t *, 943 (wchar_t *dest, const wchar_t *src, size_t n)); 944_GL_CXXALIASWARN (wcsncpy); 945#elif defined GNULIB_POSIXCHECK 946# undef wcsncpy 947# if HAVE_RAW_DECL_WCSNCPY 948_GL_WARN_ON_USE (wcsncpy, "wcsncpy is unportable - " 949 "use gnulib module wcsncpy for portability"); 950# endif 951#endif 952 953 954/* Copy no more than N characters of SRC to DEST, returning the address of 955 the last character written into DEST. */ 956#if 0 957# if !1 958_GL_FUNCDECL_SYS (wcpncpy, wchar_t *, 959 (wchar_t *dest, const wchar_t *src, size_t n)); 960# endif 961_GL_CXXALIAS_SYS (wcpncpy, wchar_t *, 962 (wchar_t *dest, const wchar_t *src, size_t n)); 963_GL_CXXALIASWARN (wcpncpy); 964#elif defined GNULIB_POSIXCHECK 965# undef wcpncpy 966# if HAVE_RAW_DECL_WCPNCPY 967_GL_WARN_ON_USE (wcpncpy, "wcpncpy is unportable - " 968 "use gnulib module wcpncpy for portability"); 969# endif 970#endif 971 972 973/* Append SRC onto DEST. */ 974#if 0 975# if !1 976_GL_FUNCDECL_SYS (wcscat, wchar_t *, (wchar_t *dest, const wchar_t *src)); 977# endif 978_GL_CXXALIAS_SYS (wcscat, wchar_t *, (wchar_t *dest, const wchar_t *src)); 979_GL_CXXALIASWARN (wcscat); 980#elif defined GNULIB_POSIXCHECK 981# undef wcscat 982# if HAVE_RAW_DECL_WCSCAT 983_GL_WARN_ON_USE (wcscat, "wcscat is unportable - " 984 "use gnulib module wcscat for portability"); 985# endif 986#endif 987 988 989/* Append no more than N wide characters of SRC onto DEST. */ 990#if 0 991# if !1 992_GL_FUNCDECL_SYS (wcsncat, wchar_t *, 993 (wchar_t *dest, const wchar_t *src, size_t n)); 994# endif 995_GL_CXXALIAS_SYS (wcsncat, wchar_t *, 996 (wchar_t *dest, const wchar_t *src, size_t n)); 997_GL_CXXALIASWARN (wcsncat); 998#elif defined GNULIB_POSIXCHECK 999# undef wcsncat 1000# if HAVE_RAW_DECL_WCSNCAT 1001_GL_WARN_ON_USE (wcsncat, "wcsncat is unportable - " 1002 "use gnulib module wcsncat for portability"); 1003# endif 1004#endif 1005 1006 1007/* Compare S1 and S2. */ 1008#if 0 1009# if !1 1010_GL_FUNCDECL_SYS (wcscmp, int, (const wchar_t *s1, const wchar_t *s2) 1011 _GL_ATTRIBUTE_PURE); 1012# endif 1013_GL_CXXALIAS_SYS (wcscmp, int, (const wchar_t *s1, const wchar_t *s2)); 1014_GL_CXXALIASWARN (wcscmp); 1015#elif defined GNULIB_POSIXCHECK 1016# undef wcscmp 1017# if HAVE_RAW_DECL_WCSCMP 1018_GL_WARN_ON_USE (wcscmp, "wcscmp is unportable - " 1019 "use gnulib module wcscmp for portability"); 1020# endif 1021#endif 1022 1023 1024/* Compare no more than N wide characters of S1 and S2. */ 1025#if 0 1026# if !1 1027_GL_FUNCDECL_SYS (wcsncmp, int, 1028 (const wchar_t *s1, const wchar_t *s2, size_t n) 1029 _GL_ATTRIBUTE_PURE); 1030# endif 1031_GL_CXXALIAS_SYS (wcsncmp, int, 1032 (const wchar_t *s1, const wchar_t *s2, size_t n)); 1033_GL_CXXALIASWARN (wcsncmp); 1034#elif defined GNULIB_POSIXCHECK 1035# undef wcsncmp 1036# if HAVE_RAW_DECL_WCSNCMP 1037_GL_WARN_ON_USE (wcsncmp, "wcsncmp is unportable - " 1038 "use gnulib module wcsncmp for portability"); 1039# endif 1040#endif 1041 1042 1043/* Compare S1 and S2, ignoring case. */ 1044#if 0 1045# if !1 1046_GL_FUNCDECL_SYS (wcscasecmp, int, (const wchar_t *s1, const wchar_t *s2) 1047 _GL_ATTRIBUTE_PURE); 1048# endif 1049_GL_CXXALIAS_SYS (wcscasecmp, int, (const wchar_t *s1, const wchar_t *s2)); 1050_GL_CXXALIASWARN (wcscasecmp); 1051#elif defined GNULIB_POSIXCHECK 1052# undef wcscasecmp 1053# if HAVE_RAW_DECL_WCSCASECMP 1054_GL_WARN_ON_USE (wcscasecmp, "wcscasecmp is unportable - " 1055 "use gnulib module wcscasecmp for portability"); 1056# endif 1057#endif 1058 1059 1060/* Compare no more than N chars of S1 and S2, ignoring case. */ 1061#if 0 1062# if !1 1063_GL_FUNCDECL_SYS (wcsncasecmp, int, 1064 (const wchar_t *s1, const wchar_t *s2, size_t n) 1065 _GL_ATTRIBUTE_PURE); 1066# endif 1067_GL_CXXALIAS_SYS (wcsncasecmp, int, 1068 (const wchar_t *s1, const wchar_t *s2, size_t n)); 1069_GL_CXXALIASWARN (wcsncasecmp); 1070#elif defined GNULIB_POSIXCHECK 1071# undef wcsncasecmp 1072# if HAVE_RAW_DECL_WCSNCASECMP 1073_GL_WARN_ON_USE (wcsncasecmp, "wcsncasecmp is unportable - " 1074 "use gnulib module wcsncasecmp for portability"); 1075# endif 1076#endif 1077 1078 1079/* Compare S1 and S2, both interpreted as appropriate to the LC_COLLATE 1080 category of the current locale. */ 1081#if 0 1082# if !1 1083_GL_FUNCDECL_SYS (wcscoll, int, (const wchar_t *s1, const wchar_t *s2)); 1084# endif 1085_GL_CXXALIAS_SYS (wcscoll, int, (const wchar_t *s1, const wchar_t *s2)); 1086_GL_CXXALIASWARN (wcscoll); 1087#elif defined GNULIB_POSIXCHECK 1088# undef wcscoll 1089# if HAVE_RAW_DECL_WCSCOLL 1090_GL_WARN_ON_USE (wcscoll, "wcscoll is unportable - " 1091 "use gnulib module wcscoll for portability"); 1092# endif 1093#endif 1094 1095 1096/* Transform S2 into array pointed to by S1 such that if wcscmp is applied 1097 to two transformed strings the result is the as applying 'wcscoll' to the 1098 original strings. */ 1099#if 0 1100# if !1 1101_GL_FUNCDECL_SYS (wcsxfrm, size_t, (wchar_t *s1, const wchar_t *s2, size_t n)); 1102# endif 1103_GL_CXXALIAS_SYS (wcsxfrm, size_t, (wchar_t *s1, const wchar_t *s2, size_t n)); 1104_GL_CXXALIASWARN (wcsxfrm); 1105#elif defined GNULIB_POSIXCHECK 1106# undef wcsxfrm 1107# if HAVE_RAW_DECL_WCSXFRM 1108_GL_WARN_ON_USE (wcsxfrm, "wcsxfrm is unportable - " 1109 "use gnulib module wcsxfrm for portability"); 1110# endif 1111#endif 1112 1113 1114/* Duplicate S, returning an identical malloc'd string. */ 1115#if 0 1116# if !1 1117_GL_FUNCDECL_SYS (wcsdup, wchar_t *, (const wchar_t *s)); 1118# endif 1119_GL_CXXALIAS_SYS (wcsdup, wchar_t *, (const wchar_t *s)); 1120_GL_CXXALIASWARN (wcsdup); 1121#elif defined GNULIB_POSIXCHECK 1122# undef wcsdup 1123# if HAVE_RAW_DECL_WCSDUP 1124_GL_WARN_ON_USE (wcsdup, "wcsdup is unportable - " 1125 "use gnulib module wcsdup for portability"); 1126# endif 1127#endif 1128 1129 1130/* Find the first occurrence of WC in WCS. */ 1131#if 0 1132# if !1 1133_GL_FUNCDECL_SYS (wcschr, wchar_t *, (const wchar_t *wcs, wchar_t wc) 1134 _GL_ATTRIBUTE_PURE); 1135# endif 1136 /* On some systems, this function is defined as an overloaded function: 1137 extern "C++" { 1138 const wchar_t * std::wcschr (const wchar_t *, wchar_t); 1139 wchar_t * std::wcschr (wchar_t *, wchar_t); 1140 } */ 1141_GL_CXXALIAS_SYS_CAST2 (wcschr, 1142 wchar_t *, (const wchar_t *, wchar_t), 1143 const wchar_t *, (const wchar_t *, wchar_t)); 1144# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \ 1145 && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) 1146_GL_CXXALIASWARN1 (wcschr, wchar_t *, (wchar_t *wcs, wchar_t wc)); 1147_GL_CXXALIASWARN1 (wcschr, const wchar_t *, (const wchar_t *wcs, wchar_t wc)); 1148# else 1149_GL_CXXALIASWARN (wcschr); 1150# endif 1151#elif defined GNULIB_POSIXCHECK 1152# undef wcschr 1153# if HAVE_RAW_DECL_WCSCHR 1154_GL_WARN_ON_USE (wcschr, "wcschr is unportable - " 1155 "use gnulib module wcschr for portability"); 1156# endif 1157#endif 1158 1159 1160/* Find the last occurrence of WC in WCS. */ 1161#if 0 1162# if !1 1163_GL_FUNCDECL_SYS (wcsrchr, wchar_t *, (const wchar_t *wcs, wchar_t wc) 1164 _GL_ATTRIBUTE_PURE); 1165# endif 1166 /* On some systems, this function is defined as an overloaded function: 1167 extern "C++" { 1168 const wchar_t * std::wcsrchr (const wchar_t *, wchar_t); 1169 wchar_t * std::wcsrchr (wchar_t *, wchar_t); 1170 } */ 1171_GL_CXXALIAS_SYS_CAST2 (wcsrchr, 1172 wchar_t *, (const wchar_t *, wchar_t), 1173 const wchar_t *, (const wchar_t *, wchar_t)); 1174# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \ 1175 && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) 1176_GL_CXXALIASWARN1 (wcsrchr, wchar_t *, (wchar_t *wcs, wchar_t wc)); 1177_GL_CXXALIASWARN1 (wcsrchr, const wchar_t *, (const wchar_t *wcs, wchar_t wc)); 1178# else 1179_GL_CXXALIASWARN (wcsrchr); 1180# endif 1181#elif defined GNULIB_POSIXCHECK 1182# undef wcsrchr 1183# if HAVE_RAW_DECL_WCSRCHR 1184_GL_WARN_ON_USE (wcsrchr, "wcsrchr is unportable - " 1185 "use gnulib module wcsrchr for portability"); 1186# endif 1187#endif 1188 1189 1190/* Return the length of the initial segmet of WCS which consists entirely 1191 of wide characters not in REJECT. */ 1192#if 0 1193# if !1 1194_GL_FUNCDECL_SYS (wcscspn, size_t, (const wchar_t *wcs, const wchar_t *reject) 1195 _GL_ATTRIBUTE_PURE); 1196# endif 1197_GL_CXXALIAS_SYS (wcscspn, size_t, (const wchar_t *wcs, const wchar_t *reject)); 1198_GL_CXXALIASWARN (wcscspn); 1199#elif defined GNULIB_POSIXCHECK 1200# undef wcscspn 1201# if HAVE_RAW_DECL_WCSCSPN 1202_GL_WARN_ON_USE (wcscspn, "wcscspn is unportable - " 1203 "use gnulib module wcscspn for portability"); 1204# endif 1205#endif 1206 1207 1208/* Return the length of the initial segmet of WCS which consists entirely 1209 of wide characters in ACCEPT. */ 1210#if 0 1211# if !1 1212_GL_FUNCDECL_SYS (wcsspn, size_t, (const wchar_t *wcs, const wchar_t *accept) 1213 _GL_ATTRIBUTE_PURE); 1214# endif 1215_GL_CXXALIAS_SYS (wcsspn, size_t, (const wchar_t *wcs, const wchar_t *accept)); 1216_GL_CXXALIASWARN (wcsspn); 1217#elif defined GNULIB_POSIXCHECK 1218# undef wcsspn 1219# if HAVE_RAW_DECL_WCSSPN 1220_GL_WARN_ON_USE (wcsspn, "wcsspn is unportable - " 1221 "use gnulib module wcsspn for portability"); 1222# endif 1223#endif 1224 1225 1226/* Find the first occurrence in WCS of any character in ACCEPT. */ 1227#if 0 1228# if !1 1229_GL_FUNCDECL_SYS (wcspbrk, wchar_t *, 1230 (const wchar_t *wcs, const wchar_t *accept) 1231 _GL_ATTRIBUTE_PURE); 1232# endif 1233 /* On some systems, this function is defined as an overloaded function: 1234 extern "C++" { 1235 const wchar_t * std::wcspbrk (const wchar_t *, const wchar_t *); 1236 wchar_t * std::wcspbrk (wchar_t *, const wchar_t *); 1237 } */ 1238_GL_CXXALIAS_SYS_CAST2 (wcspbrk, 1239 wchar_t *, (const wchar_t *, const wchar_t *), 1240 const wchar_t *, (const wchar_t *, const wchar_t *)); 1241# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \ 1242 && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) 1243_GL_CXXALIASWARN1 (wcspbrk, wchar_t *, 1244 (wchar_t *wcs, const wchar_t *accept)); 1245_GL_CXXALIASWARN1 (wcspbrk, const wchar_t *, 1246 (const wchar_t *wcs, const wchar_t *accept)); 1247# else 1248_GL_CXXALIASWARN (wcspbrk); 1249# endif 1250#elif defined GNULIB_POSIXCHECK 1251# undef wcspbrk 1252# if HAVE_RAW_DECL_WCSPBRK 1253_GL_WARN_ON_USE (wcspbrk, "wcspbrk is unportable - " 1254 "use gnulib module wcspbrk for portability"); 1255# endif 1256#endif 1257 1258 1259/* Find the first occurrence of NEEDLE in HAYSTACK. */ 1260#if 0 1261# if !1 1262_GL_FUNCDECL_SYS (wcsstr, wchar_t *, 1263 (const wchar_t *haystack, const wchar_t *needle) 1264 _GL_ATTRIBUTE_PURE); 1265# endif 1266 /* On some systems, this function is defined as an overloaded function: 1267 extern "C++" { 1268 const wchar_t * std::wcsstr (const wchar_t *, const wchar_t *); 1269 wchar_t * std::wcsstr (wchar_t *, const wchar_t *); 1270 } */ 1271_GL_CXXALIAS_SYS_CAST2 (wcsstr, 1272 wchar_t *, (const wchar_t *, const wchar_t *), 1273 const wchar_t *, (const wchar_t *, const wchar_t *)); 1274# if ((__GLIBC__ == 2 && __GLIBC_MINOR__ >= 10) && !defined __UCLIBC__) \ 1275 && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) 1276_GL_CXXALIASWARN1 (wcsstr, wchar_t *, 1277 (wchar_t *haystack, const wchar_t *needle)); 1278_GL_CXXALIASWARN1 (wcsstr, const wchar_t *, 1279 (const wchar_t *haystack, const wchar_t *needle)); 1280# else 1281_GL_CXXALIASWARN (wcsstr); 1282# endif 1283#elif defined GNULIB_POSIXCHECK 1284# undef wcsstr 1285# if HAVE_RAW_DECL_WCSSTR 1286_GL_WARN_ON_USE (wcsstr, "wcsstr is unportable - " 1287 "use gnulib module wcsstr for portability"); 1288# endif 1289#endif 1290 1291 1292/* Divide WCS into tokens separated by characters in DELIM. */ 1293#if 0 1294# if !1 1295_GL_FUNCDECL_SYS (wcstok, wchar_t *, 1296 (wchar_t *wcs, const wchar_t *delim, wchar_t **ptr)); 1297# endif 1298_GL_CXXALIAS_SYS (wcstok, wchar_t *, 1299 (wchar_t *wcs, const wchar_t *delim, wchar_t **ptr)); 1300_GL_CXXALIASWARN (wcstok); 1301#elif defined GNULIB_POSIXCHECK 1302# undef wcstok 1303# if HAVE_RAW_DECL_WCSTOK 1304_GL_WARN_ON_USE (wcstok, "wcstok is unportable - " 1305 "use gnulib module wcstok for portability"); 1306# endif 1307#endif 1308 1309 1310/* Determine number of column positions required for first N wide 1311 characters (or fewer if S ends before this) in S. */ 1312#if 0 1313# if 0 1314# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1315# undef wcswidth 1316# define wcswidth rpl_wcswidth 1317# endif 1318_GL_FUNCDECL_RPL (wcswidth, int, (const wchar_t *s, size_t n) 1319 _GL_ATTRIBUTE_PURE); 1320_GL_CXXALIAS_RPL (wcswidth, int, (const wchar_t *s, size_t n)); 1321# else 1322# if !1 1323_GL_FUNCDECL_SYS (wcswidth, int, (const wchar_t *s, size_t n) 1324 _GL_ATTRIBUTE_PURE); 1325# endif 1326_GL_CXXALIAS_SYS (wcswidth, int, (const wchar_t *s, size_t n)); 1327# endif 1328_GL_CXXALIASWARN (wcswidth); 1329#elif defined GNULIB_POSIXCHECK 1330# undef wcswidth 1331# if HAVE_RAW_DECL_WCSWIDTH 1332_GL_WARN_ON_USE (wcswidth, "wcswidth is unportable - " 1333 "use gnulib module wcswidth for portability"); 1334# endif 1335#endif 1336 1337 1338#endif /* _GL_WCHAR_H */ 1339#endif /* _GL_WCHAR_H */ 1340#endif 1341