gl/m4/mbrtowc.m4

   1 # mbrtowc.m4
   2 # serial 44  -*- coding: utf-8 -*-
   3 dnl Copyright (C) 2001-2002, 2004-2005, 2008-2024 Free Software Foundation,
   4 dnl Inc.
   5 dnl This file is free software; the Free Software Foundation
   6 dnl gives unlimited permission to copy and/or distribute it,
   7 dnl with or without modifications, as long as this notice is preserved.
   8
   9 AC_DEFUN([gl_FUNC_MBRTOWC],
  10 [
  11   AC_REQUIRE([gl_WCHAR_H_DEFAULTS])
  12   AC_REQUIRE([gl_PTHREADLIB])
  13   AC_CHECK_HEADERS_ONCE([threads.h])
  14
  15   AC_REQUIRE([AC_TYPE_MBSTATE_T])
  16   gl_MBSTATE_T_BROKEN
  17
  18   AC_CHECK_FUNCS_ONCE([mbrtowc])
  19   if test $ac_cv_func_mbrtowc = no; then
  20     HAVE_MBRTOWC=0
  21     AC_CHECK_DECLS([mbrtowc],,, [[
  22       #include <wchar.h>
  23     ]])
  24     if test $ac_cv_have_decl_mbrtowc = yes; then
  25       dnl On Minix 3.1.8, the system's <wchar.h> declares mbrtowc() although
  26       dnl it does not have the function. Avoid a collision with gnulib's
  27       dnl replacement.
  28       REPLACE_MBRTOWC=1
  29     fi
  30   else
  31     if test $REPLACE_MBSTATE_T = 1; then
  32       REPLACE_MBRTOWC=1
  33     else
  34       gl_MBRTOWC_NULL_ARG1
  35       gl_MBRTOWC_NULL_ARG2
  36       gl_MBRTOWC_RETVAL
  37       gl_MBRTOWC_NUL_RETVAL
  38       gl_MBRTOWC_STORES_INCOMPLETE
  39       gl_MBRTOWC_EMPTY_INPUT
  40       gl_MBRTOWC_C_LOCALE
  41       case "$gl_cv_func_mbrtowc_null_arg1" in
  42         *yes) ;;
  43         *) AC_DEFINE([MBRTOWC_NULL_ARG1_BUG], [1],
  44              [Define if the mbrtowc function has the NULL pwc argument bug.])
  45            REPLACE_MBRTOWC=1
  46            ;;
  47       esac
  48       case "$gl_cv_func_mbrtowc_null_arg2" in
  49         *yes) ;;
  50         *) AC_DEFINE([MBRTOWC_NULL_ARG2_BUG], [1],
  51              [Define if the mbrtowc function has the NULL string argument bug.])
  52            REPLACE_MBRTOWC=1
  53            ;;
  54       esac
  55       case "$gl_cv_func_mbrtowc_retval" in
  56         *yes) ;;
  57         *) AC_DEFINE([MBRTOWC_RETVAL_BUG], [1],
  58              [Define if the mbrtowc function returns a wrong return value.])
  59            REPLACE_MBRTOWC=1
  60            ;;
  61       esac
  62       case "$gl_cv_func_mbrtowc_nul_retval" in
  63         *yes) ;;
  64         *) AC_DEFINE([MBRTOWC_NUL_RETVAL_BUG], [1],
  65              [Define if the mbrtowc function does not return 0 for a NUL character.])
  66            REPLACE_MBRTOWC=1
  67            ;;
  68       esac
  69       case "$gl_cv_func_mbrtowc_stores_incomplete" in
  70         *no) ;;
  71         *) AC_DEFINE([MBRTOWC_STORES_INCOMPLETE_BUG], [1],
  72              [Define if the mbrtowc function stores a wide character when reporting incomplete input.])
  73            REPLACE_MBRTOWC=1
  74            ;;
  75       esac
  76       case "$gl_cv_func_mbrtowc_empty_input" in
  77         *yes) ;;
  78         *) AC_DEFINE([MBRTOWC_EMPTY_INPUT_BUG], [1],
  79              [Define if the mbrtowc function does not return (size_t) -2
  80               for empty input.])
  81            REPLACE_MBRTOWC=1
  82            ;;
  83       esac
  84       case "$gl_cv_func_mbrtowc_C_locale_sans_EILSEQ" in
  85         *yes) ;;
  86         *) AC_DEFINE([MBRTOWC_IN_C_LOCALE_MAYBE_EILSEQ], [1],
  87              [Define if the mbrtowc function may signal encoding errors in the C locale.])
  88            REPLACE_MBRTOWC=1
  89            ;;
  90       esac
  91     fi
  92   fi
  93   if test $REPLACE_MBSTATE_T = 1; then
  94     case "$host_os" in
  95       mingw* | windows*)
  96         MBRTOWC_LIB=
  97         ;;
  98       *)
  99         gl_WEAK_SYMBOLS
 100         case "$gl_cv_have_weak" in
 101           *yes) MBRTOWC_LIB= ;;
 102           *)    MBRTOWC_LIB="$LIBPTHREAD" ;;
 103         esac
 104         ;;
 105     esac
 106   else
 107     MBRTOWC_LIB=
 108   fi
 109   dnl MBRTOWC_LIB is expected to be '-pthread' or '-lpthread' on AIX
 110   dnl with gcc or xlc, and empty otherwise.
 111   AC_SUBST([MBRTOWC_LIB])
 112   dnl For backward compatibility.
 113   LIB_MBRTOWC="$MBRTOWC_LIB"
 114   AC_SUBST([LIB_MBRTOWC])
 115 ])
 116
 117 dnl Test whether mbsinit() and mbrtowc() need to be overridden in a way that
 118 dnl redefines the semantics of the given mbstate_t type.
 119 dnl Result is REPLACE_MBSTATE_T.
 120 dnl When this is set to 1, we replace both mbsinit() and mbrtowc(), in order to
 121 dnl avoid inconsistencies.
 122
 123 AC_DEFUN_ONCE([gl_MBSTATE_T_BROKEN],
 124 [
 125   AC_REQUIRE([gl_WCHAR_H_DEFAULTS])
 126   AC_REQUIRE([AC_CANONICAL_HOST])
 127
 128   AC_REQUIRE([AC_TYPE_MBSTATE_T])
 129   AC_CHECK_FUNCS_ONCE([mbsinit])
 130   AC_CHECK_FUNCS_ONCE([mbrtowc])
 131   dnl On native Windows, we know exactly how mbsinit() behaves and don't need
 132   dnl to override it, even if - like on MSVC - mbsinit() is only defined as
 133   dnl an inline function, not as a global function.
 134   if case "$host_os" in
 135        mingw* | windows*) true ;;
 136        *) test $ac_cv_func_mbsinit = yes ;;
 137      esac \
 138     && test $ac_cv_func_mbrtowc = yes; then
 139     gl_MBRTOWC_INCOMPLETE_STATE
 140     gl_MBRTOWC_SANITYCHECK
 141     REPLACE_MBSTATE_T=0
 142     case "$gl_cv_func_mbrtowc_incomplete_state" in
 143       *yes) ;;
 144       *) REPLACE_MBSTATE_T=1 ;;
 145     esac
 146     case "$gl_cv_func_mbrtowc_sanitycheck" in
 147       *yes) ;;
 148       *) REPLACE_MBSTATE_T=1 ;;
 149     esac
 150   else
 151     REPLACE_MBSTATE_T=1
 152   fi
 153 ])
 154
 155 dnl Test whether mbrtowc puts the state into non-initial state when parsing an
 156 dnl incomplete multibyte character.
 157 dnl Result is gl_cv_func_mbrtowc_incomplete_state.
 158
 159 AC_DEFUN([gl_MBRTOWC_INCOMPLETE_STATE],
 160 [
 161   AC_REQUIRE([AC_PROG_CC])
 162   AC_REQUIRE([gt_LOCALE_JA])
 163   AC_REQUIRE([gt_LOCALE_FR_UTF8])
 164   AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
 165   AC_CACHE_CHECK([whether mbrtowc handles incomplete characters],
 166     [gl_cv_func_mbrtowc_incomplete_state],
 167     [
 168       dnl Initial guess, used when cross-compiling or when no suitable locale
 169       dnl is present.
 170 changequote(,)dnl
 171       case "$host_os" in
 172                      # Guess no on AIX and OSF/1.
 173         aix* | osf*) gl_cv_func_mbrtowc_incomplete_state="guessing no" ;;
 174                      # Guess yes otherwise.
 175         *)           gl_cv_func_mbrtowc_incomplete_state="guessing yes" ;;
 176       esac
 177 changequote([,])dnl
 178       if test $LOCALE_JA != none; then
 179         AC_RUN_IFELSE(
 180           [AC_LANG_SOURCE([[
 181 #include <locale.h>
 182 #include <string.h>
 183 #include <wchar.h>
 184 int main ()
 185 {
 186   if (setlocale (LC_ALL, "$LOCALE_JA") != NULL)
 187     {
 188       const char input[] = "B\217\253\344\217\251\316er"; /* "Büßer" */
 189       mbstate_t state;
 190       wchar_t wc;
 191
 192       memset (&state, '\0', sizeof (mbstate_t));
 193       if (mbrtowc (&wc, input + 1, 1, &state) == (size_t)(-2))
 194         if (mbsinit (&state))
 195           return 2;
 196     }
 197   return 0;
 198 }]])],
 199           [gl_cv_func_mbrtowc_incomplete_state=yes],
 200           [gl_cv_func_mbrtowc_incomplete_state=no],
 201           [:])
 202       else
 203         if test $LOCALE_FR_UTF8 != none; then
 204           AC_RUN_IFELSE(
 205             [AC_LANG_SOURCE([[
 206 #include <locale.h>
 207 #include <string.h>
 208 #include <wchar.h>
 209 int main ()
 210 {
 211   if (setlocale (LC_ALL, "$LOCALE_FR_UTF8") != NULL)
 212     {
 213       const char input[] = "B\303\274\303\237er"; /* "Büßer" */
 214       mbstate_t state;
 215       wchar_t wc;
 216
 217       memset (&state, '\0', sizeof (mbstate_t));
 218       if (mbrtowc (&wc, input + 1, 1, &state) == (size_t)(-2))
 219         if (mbsinit (&state))
 220           return 2;
 221     }
 222   return 0;
 223 }]])],
 224           [gl_cv_func_mbrtowc_incomplete_state=yes],
 225           [gl_cv_func_mbrtowc_incomplete_state=no],
 226           [:])
 227         fi
 228       fi
 229     ])
 230 ])
 231
 232 dnl Test whether mbrtowc works not worse than mbtowc.
 233 dnl Result is gl_cv_func_mbrtowc_sanitycheck.
 234
 235 AC_DEFUN([gl_MBRTOWC_SANITYCHECK],
 236 [
 237   AC_REQUIRE([AC_PROG_CC])
 238   AC_REQUIRE([gt_LOCALE_ZH_CN])
 239   AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
 240   AC_CACHE_CHECK([whether mbrtowc works as well as mbtowc],
 241     [gl_cv_func_mbrtowc_sanitycheck],
 242     [
 243       dnl Initial guess, used when cross-compiling or when no suitable locale
 244       dnl is present.
 245 changequote(,)dnl
 246       case "$host_os" in
 247                     # Guess no on Solaris 8.
 248         solaris2.8) gl_cv_func_mbrtowc_sanitycheck="guessing no" ;;
 249                     # Guess yes otherwise.
 250         *)          gl_cv_func_mbrtowc_sanitycheck="guessing yes" ;;
 251       esac
 252 changequote([,])dnl
 253       if test $LOCALE_ZH_CN != none; then
 254         AC_RUN_IFELSE(
 255           [AC_LANG_SOURCE([[
 256 #include <locale.h>
 257 #include <stdlib.h>
 258 #include <string.h>
 259 #include <wchar.h>
 260 int main ()
 261 {
 262   /* This fails on Solaris 8:
 263      mbrtowc returns 2, and sets wc to 0x00F0.
 264      mbtowc returns 4 (correct) and sets wc to 0x5EDC.  */
 265   if (setlocale (LC_ALL, "$LOCALE_ZH_CN") != NULL)
 266     {
 267       char input[] = "B\250\271\201\060\211\070er"; /* "Büßer" */
 268       mbstate_t state;
 269       wchar_t wc;
 270
 271       memset (&state, '\0', sizeof (mbstate_t));
 272       if (mbrtowc (&wc, input + 3, 6, &state) != 4
 273           && mbtowc (&wc, input + 3, 6) == 4)
 274         return 2;
 275     }
 276   return 0;
 277 }]])],
 278           [gl_cv_func_mbrtowc_sanitycheck=yes],
 279           [gl_cv_func_mbrtowc_sanitycheck=no],
 280           [:])
 281       fi
 282     ])
 283 ])
 284
 285 dnl Test whether mbrtowc supports a NULL pwc argument correctly.
 286 dnl Result is gl_cv_func_mbrtowc_null_arg1.
 287
 288 AC_DEFUN([gl_MBRTOWC_NULL_ARG1],
 289 [
 290   AC_REQUIRE([AC_PROG_CC])
 291   AC_REQUIRE([gt_LOCALE_FR_UTF8])
 292   AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
 293   AC_CACHE_CHECK([whether mbrtowc handles a NULL pwc argument],
 294     [gl_cv_func_mbrtowc_null_arg1],
 295     [
 296       dnl Initial guess, used when cross-compiling or when no suitable locale
 297       dnl is present.
 298 changequote(,)dnl
 299       case "$host_os" in
 300                   # Guess no on Solaris.
 301         solaris*) gl_cv_func_mbrtowc_null_arg1="guessing no" ;;
 302                   # Guess yes otherwise.
 303         *)        gl_cv_func_mbrtowc_null_arg1="guessing yes" ;;
 304       esac
 305 changequote([,])dnl
 306       if test $LOCALE_FR_UTF8 != none; then
 307         AC_RUN_IFELSE(
 308           [AC_LANG_SOURCE([[
 309 #include <locale.h>
 310 #include <stdlib.h>
 311 #include <string.h>
 312 #include <wchar.h>
 313 int main ()
 314 {
 315   int result = 0;
 316
 317   if (setlocale (LC_ALL, "$LOCALE_FR_UTF8") != NULL)
 318     {
 319       char input[] = "\303\237er";
 320       mbstate_t state;
 321       wchar_t wc;
 322       size_t ret;
 323
 324       memset (&state, '\0', sizeof (mbstate_t));
 325       wc = (wchar_t) 0xBADFACE;
 326       ret = mbrtowc (&wc, input, 5, &state);
 327       if (ret != 2)
 328         result |= 1;
 329       if (!mbsinit (&state))
 330         result |= 2;
 331
 332       memset (&state, '\0', sizeof (mbstate_t));
 333       ret = mbrtowc (NULL, input, 5, &state);
 334       if (ret != 2) /* Solaris 7 fails here: ret is -1.  */
 335         result |= 4;
 336       if (!mbsinit (&state))
 337         result |= 8;
 338     }
 339   return result;
 340 }]])],
 341           [gl_cv_func_mbrtowc_null_arg1=yes],
 342           [gl_cv_func_mbrtowc_null_arg1=no],
 343           [:])
 344       fi
 345     ])
 346 ])
 347
 348 dnl Test whether mbrtowc supports a NULL string argument correctly.
 349 dnl Result is gl_cv_func_mbrtowc_null_arg2.
 350
 351 AC_DEFUN([gl_MBRTOWC_NULL_ARG2],
 352 [
 353   AC_REQUIRE([AC_PROG_CC])
 354   AC_REQUIRE([gt_LOCALE_FR_UTF8])
 355   AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
 356   AC_CACHE_CHECK([whether mbrtowc handles a NULL string argument],
 357     [gl_cv_func_mbrtowc_null_arg2],
 358     [
 359       dnl Initial guess, used when cross-compiling or when no suitable locale
 360       dnl is present.
 361 changequote(,)dnl
 362       case "$host_os" in
 363               # Guess no on OSF/1.
 364         osf*) gl_cv_func_mbrtowc_null_arg2="guessing no" ;;
 365               # Guess yes otherwise.
 366         *)    gl_cv_func_mbrtowc_null_arg2="guessing yes" ;;
 367       esac
 368 changequote([,])dnl
 369       if test $LOCALE_FR_UTF8 != none; then
 370         AC_RUN_IFELSE(
 371           [AC_LANG_SOURCE([[
 372 #include <locale.h>
 373 #include <string.h>
 374 #include <wchar.h>
 375 int main ()
 376 {
 377   if (setlocale (LC_ALL, "$LOCALE_FR_UTF8") != NULL)
 378     {
 379       mbstate_t state;
 380       wchar_t wc;
 381       int ret;
 382
 383       memset (&state, '\0', sizeof (mbstate_t));
 384       wc = (wchar_t) 0xBADFACE;
 385       mbrtowc (&wc, NULL, 5, &state);
 386       /* Check that wc was not modified.  */
 387       if (wc != (wchar_t) 0xBADFACE)
 388         return 2;
 389     }
 390   return 0;
 391 }]])],
 392           [gl_cv_func_mbrtowc_null_arg2=yes],
 393           [gl_cv_func_mbrtowc_null_arg2=no],
 394           [:])
 395       fi
 396     ])
 397 ])
 398
 399 dnl Test whether mbrtowc, when parsing the end of a multibyte character,
 400 dnl correctly returns the number of bytes that were needed to complete the
 401 dnl character (not the total number of bytes of the multibyte character).
 402 dnl Result is gl_cv_func_mbrtowc_retval.
 403
 404 AC_DEFUN([gl_MBRTOWC_RETVAL],
 405 [
 406   AC_REQUIRE([AC_PROG_CC])
 407   AC_REQUIRE([gt_LOCALE_FR_UTF8])
 408   AC_REQUIRE([gt_LOCALE_JA])
 409   AC_REQUIRE([AC_CANONICAL_HOST])
 410   AC_CACHE_CHECK([whether mbrtowc has a correct return value],
 411     [gl_cv_func_mbrtowc_retval],
 412     [
 413       dnl Initial guess, used when cross-compiling or when no suitable locale
 414       dnl is present.
 415 changequote(,)dnl
 416       case "$host_os" in
 417           # Guess no on HP-UX, Solaris, native Windows.
 418         hpux* | solaris* | mingw* | windows*)
 419           gl_cv_func_mbrtowc_retval="guessing no" ;;
 420           # Guess yes otherwise.
 421         *)
 422           gl_cv_func_mbrtowc_retval="guessing yes" ;;
 423       esac
 424 changequote([,])dnl
 425       if test $LOCALE_FR_UTF8 != none || test $LOCALE_JA != none \
 426          || { case "$host_os" in mingw* | windows*) true;; *) false;; esac; }; then
 427         AC_RUN_IFELSE(
 428           [AC_LANG_SOURCE([[
 429 #include <locale.h>
 430 #include <string.h>
 431 #include <wchar.h>
 432 int main ()
 433 {
 434   int result = 0;
 435   int found_some_locale = 0;
 436   /* This fails on Solaris.  */
 437   if (strcmp ("$LOCALE_FR_UTF8", "none") != 0
 438       && setlocale (LC_ALL, "$LOCALE_FR_UTF8") != NULL)
 439     {
 440       char input[] = "B\303\274\303\237er"; /* "Büßer" */
 441       mbstate_t state;
 442       wchar_t wc;
 443
 444       memset (&state, '\0', sizeof (mbstate_t));
 445       if (mbrtowc (&wc, input + 1, 1, &state) == (size_t)(-2))
 446         {
 447           input[1] = '\0';
 448           if (mbrtowc (&wc, input + 2, 5, &state) != 1)
 449             result |= 1;
 450         }
 451       found_some_locale = 1;
 452     }
 453   /* This fails on HP-UX 11.11.  */
 454   if (strcmp ("$LOCALE_JA", "none") != 0
 455       && setlocale (LC_ALL, "$LOCALE_JA") != NULL)
 456     {
 457       char input[] = "B\217\253\344\217\251\316er"; /* "Büßer" */
 458       mbstate_t state;
 459       wchar_t wc;
 460
 461       memset (&state, '\0', sizeof (mbstate_t));
 462       if (mbrtowc (&wc, input + 1, 1, &state) == (size_t)(-2))
 463         {
 464           input[1] = '\0';
 465           if (mbrtowc (&wc, input + 2, 5, &state) != 2)
 466             result |= 2;
 467         }
 468       found_some_locale = 1;
 469     }
 470   /* This fails on native Windows.  */
 471   if (setlocale (LC_ALL, "Japanese_Japan.932") != NULL)
 472     {
 473       char input[] = "<\223\372\226\173\214\352>"; /* "<日本語>" */
 474       mbstate_t state;
 475       wchar_t wc;
 476
 477       memset (&state, '\0', sizeof (mbstate_t));
 478       if (mbrtowc (&wc, input + 3, 1, &state) == (size_t)(-2))
 479         {
 480           input[3] = '\0';
 481           if (mbrtowc (&wc, input + 4, 4, &state) != 1)
 482             result |= 4;
 483         }
 484       found_some_locale = 1;
 485     }
 486   if (setlocale (LC_ALL, "Chinese_Taiwan.950") != NULL)
 487     {
 488       char input[] = "<\244\351\245\273\273\171>"; /* "<日本語>" */
 489       mbstate_t state;
 490       wchar_t wc;
 491
 492       memset (&state, '\0', sizeof (mbstate_t));
 493       if (mbrtowc (&wc, input + 3, 1, &state) == (size_t)(-2))
 494         {
 495           input[3] = '\0';
 496           if (mbrtowc (&wc, input + 4, 4, &state) != 1)
 497             result |= 8;
 498         }
 499       found_some_locale = 1;
 500     }
 501   if (setlocale (LC_ALL, "Chinese_China.936") != NULL)
 502     {
 503       char input[] = "<\310\325\261\276\325\132>"; /* "<日本語>" */
 504       mbstate_t state;
 505       wchar_t wc;
 506
 507       memset (&state, '\0', sizeof (mbstate_t));
 508       if (mbrtowc (&wc, input + 3, 1, &state) == (size_t)(-2))
 509         {
 510           input[3] = '\0';
 511           if (mbrtowc (&wc, input + 4, 4, &state) != 1)
 512             result |= 16;
 513         }
 514       found_some_locale = 1;
 515     }
 516   return (found_some_locale ? result : 77);
 517 }]])],
 518           [gl_cv_func_mbrtowc_retval=yes],
 519           [if test $? != 77; then
 520              gl_cv_func_mbrtowc_retval=no
 521            fi
 522           ],
 523           [:])
 524       fi
 525     ])
 526 ])
 527
 528 dnl Test whether mbrtowc, when parsing a NUL character, correctly returns 0.
 529 dnl Result is gl_cv_func_mbrtowc_nul_retval.
 530
 531 AC_DEFUN([gl_MBRTOWC_NUL_RETVAL],
 532 [
 533   AC_REQUIRE([AC_PROG_CC])
 534   AC_REQUIRE([gt_LOCALE_ZH_CN])
 535   AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
 536   AC_CACHE_CHECK([whether mbrtowc returns 0 when parsing a NUL character],
 537     [gl_cv_func_mbrtowc_nul_retval],
 538     [
 539       dnl Initial guess, used when cross-compiling or when no suitable locale
 540       dnl is present.
 541 changequote(,)dnl
 542       case "$host_os" in
 543                        # Guess no on Solaris 8 and 9.
 544         solaris2.[89]) gl_cv_func_mbrtowc_nul_retval="guessing no" ;;
 545                        # Guess yes otherwise.
 546         *)             gl_cv_func_mbrtowc_nul_retval="guessing yes" ;;
 547       esac
 548 changequote([,])dnl
 549       if test $LOCALE_ZH_CN != none; then
 550         AC_RUN_IFELSE(
 551           [AC_LANG_SOURCE([[
 552 #include <locale.h>
 553 #include <string.h>
 554 #include <wchar.h>
 555 int main ()
 556 {
 557   /* This fails on Solaris 8 and 9.  */
 558   if (setlocale (LC_ALL, "$LOCALE_ZH_CN") != NULL)
 559     {
 560       mbstate_t state;
 561       wchar_t wc;
 562
 563       memset (&state, '\0', sizeof (mbstate_t));
 564       if (mbrtowc (&wc, "", 1, &state) != 0)
 565         return 2;
 566     }
 567   return 0;
 568 }]])],
 569           [gl_cv_func_mbrtowc_nul_retval=yes],
 570           [gl_cv_func_mbrtowc_nul_retval=no],
 571           [:])
 572       fi
 573     ])
 574 ])
 575
 576 dnl Test whether mbrtowc stores a wide character when reporting incomplete
 577 dnl input.
 578
 579 AC_DEFUN([gl_MBRTOWC_STORES_INCOMPLETE],
 580 [
 581   AC_REQUIRE([AC_PROG_CC])
 582   AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
 583   AC_CACHE_CHECK([whether mbrtowc stores incomplete characters],
 584     [gl_cv_func_mbrtowc_stores_incomplete],
 585     [
 586      dnl Initial guess, used when cross-compiling or when no suitable locale
 587      dnl is present.
 588 changequote(,)dnl
 589      case "$host_os" in
 590                           # Guess yes on native Windows.
 591        mingw* | windows*) gl_cv_func_mbrtowc_stores_incomplete="guessing yes" ;;
 592        *)                 gl_cv_func_mbrtowc_stores_incomplete="guessing no" ;;
 593      esac
 594 changequote([,])dnl
 595      case "$host_os" in
 596        mingw* | windows*)
 597          AC_RUN_IFELSE(
 598            [AC_LANG_SOURCE([[
 599 #include <locale.h>
 600 #include <string.h>
 601 #include <wchar.h>
 602 int main ()
 603 {
 604   int result = 0;
 605   if (setlocale (LC_ALL, "French_France.65001") != NULL)
 606     {
 607       wchar_t wc = (wchar_t) 0xBADFACE;
 608       mbstate_t state;
 609
 610       memset (&state, '\0', sizeof (mbstate_t));
 611       if (mbrtowc (&wc, "\303", 1, &state) == (size_t)(-2)
 612           && wc != (wchar_t) 0xBADFACE)
 613         result |= 1;
 614     }
 615   if (setlocale (LC_ALL, "Japanese_Japan.932") != NULL)
 616     {
 617       wchar_t wc = (wchar_t) 0xBADFACE;
 618       mbstate_t state;
 619
 620       memset (&state, '\0', sizeof (mbstate_t));
 621       if (mbrtowc (&wc, "\226", 1, &state) == (size_t)(-2)
 622           && wc != (wchar_t) 0xBADFACE)
 623         result |= 2;
 624     }
 625   if (setlocale (LC_ALL, "Chinese_Taiwan.950") != NULL)
 626     {
 627       wchar_t wc = (wchar_t) 0xBADFACE;
 628       mbstate_t state;
 629
 630       memset (&state, '\0', sizeof (mbstate_t));
 631       if (mbrtowc (&wc, "\245", 1, &state) == (size_t)(-2)
 632           && wc != (wchar_t) 0xBADFACE)
 633         result |= 4;
 634     }
 635   if (setlocale (LC_ALL, "Chinese_China.936") != NULL)
 636     {
 637       wchar_t wc = (wchar_t) 0xBADFACE;
 638       mbstate_t state;
 639
 640       memset (&state, '\0', sizeof (mbstate_t));
 641       if (mbrtowc (&wc, "\261", 1, &state) == (size_t)(-2)
 642           && wc != (wchar_t) 0xBADFACE)
 643         result |= 8;
 644     }
 645   return result;
 646 }]])],
 647            [gl_cv_func_mbrtowc_stores_incomplete=no],
 648            [gl_cv_func_mbrtowc_stores_incomplete=yes],
 649            [:])
 650          ;;
 651        *)
 652          AC_REQUIRE([gt_LOCALE_FR_UTF8])
 653          if test $LOCALE_FR_UTF8 != none; then
 654            AC_RUN_IFELSE(
 655              [AC_LANG_SOURCE([[
 656 #include <locale.h>
 657 #include <string.h>
 658 #include <wchar.h>
 659 int main ()
 660 {
 661   if (setlocale (LC_ALL, "$LOCALE_FR_UTF8") != NULL)
 662     {
 663       wchar_t wc = (wchar_t) 0xBADFACE;
 664       mbstate_t state;
 665
 666       memset (&state, '\0', sizeof (mbstate_t));
 667       if (mbrtowc (&wc, "\303", 1, &state) == (size_t)(-2)
 668           && wc != (wchar_t) 0xBADFACE)
 669         return 1;
 670     }
 671   return 0;
 672 }]])],
 673              [gl_cv_func_mbrtowc_stores_incomplete=no],
 674              [gl_cv_func_mbrtowc_stores_incomplete=yes],
 675              [:])
 676          fi
 677          ;;
 678      esac
 679     ])
 680 ])
 681
 682 dnl Test whether mbrtowc returns the correct value on empty input.
 683
 684 AC_DEFUN([gl_MBRTOWC_EMPTY_INPUT],
 685 [
 686   AC_REQUIRE([AC_PROG_CC])
 687   AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
 688   AC_CACHE_CHECK([whether mbrtowc works on empty input],
 689     [gl_cv_func_mbrtowc_empty_input],
 690     [AC_RUN_IFELSE(
 691        [AC_LANG_SOURCE([[
 692           #include <wchar.h>
 693           static wchar_t wc;
 694           static mbstate_t mbs;
 695           int
 696           main (void)
 697           {
 698             return mbrtowc (&wc, "", 0, &mbs) != (size_t) -2;
 699           }]])],
 700        [gl_cv_func_mbrtowc_empty_input=yes],
 701        [gl_cv_func_mbrtowc_empty_input=no],
 702        [case "$host_os" in
 703                                 # Guess no on AIX and glibc systems.
 704           aix* | *-gnu* | gnu*) gl_cv_func_mbrtowc_empty_input="guessing no" ;;
 705                                 # Guess no on Android.
 706           linux*-android*)      gl_cv_func_mbrtowc_empty_input="guessing no" ;;
 707                                 # Guess no on native Windows.
 708           mingw* | windows*)    gl_cv_func_mbrtowc_empty_input="guessing no" ;;
 709           *)                    gl_cv_func_mbrtowc_empty_input="guessing yes" ;;
 710         esac
 711        ])
 712     ])
 713 ])
 714
 715 dnl Test whether mbrtowc reports encoding errors in the C locale.
 716 dnl Although POSIX was never intended to allow this, the GNU C Library
 717 dnl and other implementations do it.  See:
 718 dnl https://sourceware.org/bugzilla/show_bug.cgi?id=19932
 719 dnl POSIX has now clarified it:
 720 dnl <https://pubs.opengroup.org/onlinepubs/9699919799/functions/mbrtowc.html>
 721 dnl says: "In the POSIX locale an [EILSEQ] error cannot occur since all byte
 722 dnl values are valid characters."
 723
 724 AC_DEFUN([gl_MBRTOWC_C_LOCALE],
 725 [
 726   AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
 727   AC_CACHE_CHECK([whether the C locale is free of encoding errors],
 728     [gl_cv_func_mbrtowc_C_locale_sans_EILSEQ],
 729     [AC_RUN_IFELSE(
 730        [AC_LANG_PROGRAM(
 731           [[#include <limits.h>
 732             #include <locale.h>
 733             #include <wchar.h>
 734           ]], [[
 735             int i;
 736             char *locale = setlocale (LC_ALL, "C");
 737             if (! locale)
 738               return 2;
 739             for (i = CHAR_MIN; i <= CHAR_MAX; i++)
 740               {
 741                 char c = i;
 742                 wchar_t wc;
 743                 mbstate_t mbs = { 0, };
 744                 size_t ss = mbrtowc (&wc, &c, 1, &mbs);
 745                 if (1 < ss)
 746                   return 3;
 747               }
 748             return 0;
 749           ]])],
 750        [gl_cv_func_mbrtowc_C_locale_sans_EILSEQ=yes],
 751        [gl_cv_func_mbrtowc_C_locale_sans_EILSEQ=no],
 752        [case "$host_os" in
 753                              # Guess yes on native Windows.
 754           mingw* | windows*) gl_cv_func_mbrtowc_C_locale_sans_EILSEQ="guessing yes" ;;
 755           *)                 gl_cv_func_mbrtowc_C_locale_sans_EILSEQ="$gl_cross_guess_normal" ;;
 756         esac
 757        ])
 758     ])
 759 ])
 760
 761 # Prerequisites of lib/mbrtowc.c and lib/lc-charset-dispatch.c.
 762 AC_DEFUN([gl_PREREQ_MBRTOWC], [
 763   AC_REQUIRE([AC_C_INLINE])
 764   :
 765 ])
 766
 767 # Prerequisites of lib/mbtowc-lock.c.
 768 AC_DEFUN([gl_PREREQ_MBTOWC_LOCK],
 769 [
 770   gl_VISIBILITY
 771 ])
 772
 773
 774 dnl From Paul Eggert
 775
 776 dnl This is an override of an autoconf macro.
 777
 778 AC_DEFUN([AC_FUNC_MBRTOWC],
 779 [
 780   dnl Same as AC_FUNC_MBRTOWC in autoconf-2.60.
 781   AC_CACHE_CHECK([whether mbrtowc and mbstate_t are properly declared],
 782     [gl_cv_func_mbrtowc],
 783     [AC_LINK_IFELSE(
 784        [AC_LANG_PROGRAM(
 785             [[#include <wchar.h>]],
 786             [[wchar_t wc;
 787               char const s[] = "";
 788               size_t n = 1;
 789               mbstate_t state;
 790               return ! (sizeof state && (mbrtowc) (&wc, s, n, &state));]])],
 791        [gl_cv_func_mbrtowc=yes],
 792        [gl_cv_func_mbrtowc=no])])
 793   if test $gl_cv_func_mbrtowc = yes; then
 794     AC_DEFINE([HAVE_MBRTOWC], [1],
 795       [Define to 1 if mbrtowc and mbstate_t are properly declared.])
 796   fi
 797 ])