libio/iofwide.c

   1 /* Copyright (C) 1999-2015 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <http://www.gnu.org/licenses/>.
  17
  18    As a special exception, if you link the code in this file with
  19    files compiled with a GNU compiler to produce an executable,
  20    that does not cause the resulting executable to be covered by
  21    the GNU Lesser General Public License.  This exception does not
  22    however invalidate any other reasons why the executable file
  23    might be covered by the GNU Lesser General Public License.
  24    This exception applies to code released by its copyright holders
  25    in files containing the exception.  */
  26
  27 #include <libioP.h>
  28 #ifdef _LIBC
  29 # include <dlfcn.h>
  30 # include <wchar.h>
  31 #endif
  32 #include <assert.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35
  36 #ifdef _LIBC
  37 # include <langinfo.h>
  38 # include <locale/localeinfo.h>
  39 # include <wcsmbs/wcsmbsload.h>
  40 # include <iconv/gconv_int.h>
  41 # include <shlib-compat.h>
  42 # include <sysdep.h>
  43 #endif
  44
  45
  46 /* Prototypes of libio's codecvt functions.  */
  47 static enum __codecvt_result do_out (struct _IO_codecvt *codecvt,
  48                                      __mbstate_t *statep,
  49                                      const wchar_t *from_start,
  50                                      const wchar_t *from_end,
  51                                      const wchar_t **from_stop, char *to_start,
  52                                      char *to_end, char **to_stop);
  53 static enum __codecvt_result do_unshift (struct _IO_codecvt *codecvt,
  54                                          __mbstate_t *statep, char *to_start,
  55                                          char *to_end, char **to_stop);
  56 static enum __codecvt_result do_in (struct _IO_codecvt *codecvt,
  57                                     __mbstate_t *statep,
  58                                     const char *from_start,
  59                                     const char *from_end,
  60                                     const char **from_stop, wchar_t *to_start,
  61                                     wchar_t *to_end, wchar_t **to_stop);
  62 static int do_encoding (struct _IO_codecvt *codecvt);
  63 static int do_length (struct _IO_codecvt *codecvt, __mbstate_t *statep,
  64                       const char *from_start,
  65                       const char *from_end, _IO_size_t max);
  66 static int do_max_length (struct _IO_codecvt *codecvt);
  67 static int do_always_noconv (struct _IO_codecvt *codecvt);
  68
  69
  70 /* The functions used in `codecvt' for libio are always the same.  */
  71 const struct _IO_codecvt __libio_codecvt =
  72 {
  73   .__codecvt_destr = NULL,              /* Destructor, never used.  */
  74   .__codecvt_do_out = do_out,
  75   .__codecvt_do_unshift = do_unshift,
  76   .__codecvt_do_in = do_in,
  77   .__codecvt_do_encoding = do_encoding,
  78   .__codecvt_do_always_noconv = do_always_noconv,
  79   .__codecvt_do_length = do_length,
  80   .__codecvt_do_max_length = do_max_length
  81 };
  82
  83
  84 /* Return orientation of stream.  If mode is nonzero try to change
  85    the orientation first.  */
  86 #undef _IO_fwide
  87 int
  88 _IO_fwide (_IO_FILE *fp, int mode)
  89 {
  90   /* Normalize the value.  */
  91   mode = mode < 0 ? -1 : (mode == 0 ? 0 : 1);
  92
  93 #if defined SHARED && defined _LIBC \
  94     && SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_1)
  95   if (__builtin_expect (&_IO_stdin_used == NULL, 0)
  96       && (fp == _IO_stdin || fp == _IO_stdout || fp == _IO_stderr))
  97     /* This is for a stream in the glibc 2.0 format.  */
  98     return -1;
  99 #endif
 100
 101   /* The orientation already has been determined.  */
 102   if (fp->_mode != 0
 103       /* Or the caller simply wants to know about the current orientation.  */
 104       || mode == 0)
 105     return fp->_mode;
 106
 107   /* Set the orientation appropriately.  */
 108   if (mode > 0)
 109     {
 110       struct _IO_codecvt *cc = fp->_codecvt = &fp->_wide_data->_codecvt;
 111
 112       fp->_wide_data->_IO_read_ptr = fp->_wide_data->_IO_read_end;
 113       fp->_wide_data->_IO_write_ptr = fp->_wide_data->_IO_write_base;
 114
 115       /* Get the character conversion functions based on the currently
 116          selected locale for LC_CTYPE.  */
 117 #ifdef _LIBC
 118       {
 119         /* Clear the state.  We start all over again.  */
 120         memset (&fp->_wide_data->_IO_state, '\0', sizeof (__mbstate_t));
 121         memset (&fp->_wide_data->_IO_last_state, '\0', sizeof (__mbstate_t));
 122
 123         struct gconv_fcts fcts;
 124         __wcsmbs_clone_conv (&fcts);
 125         assert (fcts.towc_nsteps == 1);
 126         assert (fcts.tomb_nsteps == 1);
 127
 128         /* The functions are always the same.  */
 129         *cc = __libio_codecvt;
 130
 131         cc->__cd_in.__cd.__nsteps = fcts.towc_nsteps;
 132         cc->__cd_in.__cd.__steps = fcts.towc;
 133
 134         cc->__cd_in.__cd.__data[0].__invocation_counter = 0;
 135         cc->__cd_in.__cd.__data[0].__internal_use = 1;
 136         cc->__cd_in.__cd.__data[0].__flags = __GCONV_IS_LAST;
 137         cc->__cd_in.__cd.__data[0].__statep = &fp->_wide_data->_IO_state;
 138
 139         cc->__cd_out.__cd.__nsteps = fcts.tomb_nsteps;
 140         cc->__cd_out.__cd.__steps = fcts.tomb;
 141
 142         cc->__cd_out.__cd.__data[0].__invocation_counter = 0;
 143         cc->__cd_out.__cd.__data[0].__internal_use = 1;
 144         cc->__cd_out.__cd.__data[0].__flags
 145           = __GCONV_IS_LAST | __GCONV_TRANSLIT;
 146         cc->__cd_out.__cd.__data[0].__statep = &fp->_wide_data->_IO_state;
 147       }
 148 #else
 149 # ifdef _GLIBCPP_USE_WCHAR_T
 150       {
 151         /* Determine internal and external character sets.
 152
 153            XXX For now we make our life easy: we assume a fixed internal
 154            encoding (as most sane systems have; hi HP/UX!).  If somebody
 155            cares about systems which changing internal charsets they
 156            should come up with a solution for the determination of the
 157            currently used internal character set.  */
 158         const char *internal_ccs = _G_INTERNAL_CCS;
 159         const char *external_ccs = NULL;
 160
 161 #  ifdef HAVE_NL_LANGINFO
 162         external_ccs = nl_langinfo (CODESET);
 163 #  endif
 164         if (external_ccs == NULL)
 165           external_ccs = "ISO-8859-1";
 166
 167         cc->__cd_in = iconv_open (internal_ccs, external_ccs);
 168         if (cc->__cd_in != (iconv_t) -1)
 169           cc->__cd_out = iconv_open (external_ccs, internal_ccs);
 170
 171         if (cc->__cd_in == (iconv_t) -1 || cc->__cd_out == (iconv_t) -1)
 172           {
 173             if (cc->__cd_in != (iconv_t) -1)
 174               iconv_close (cc->__cd_in);
 175             /* XXX */
 176             abort ();
 177           }
 178       }
 179 # else
 180 #  error "somehow determine this from LC_CTYPE"
 181 # endif
 182 #endif
 183
 184       /* From now on use the wide character callback functions.  */
 185       _IO_JUMPS_FILE_plus (fp) = fp->_wide_data->_wide_vtable;
 186     }
 187
 188   /* Set the mode now.  */
 189   fp->_mode = mode;
 190
 191   return mode;
 192 }
 193
 194
 195 static enum __codecvt_result
 196 do_out (struct _IO_codecvt *codecvt, __mbstate_t *statep,
 197         const wchar_t *from_start, const wchar_t *from_end,
 198         const wchar_t **from_stop, char *to_start, char *to_end,
 199         char **to_stop)
 200 {
 201   enum __codecvt_result result;
 202
 203 #ifdef _LIBC
 204   struct __gconv_step *gs = codecvt->__cd_out.__cd.__steps;
 205   int status;
 206   size_t dummy;
 207   const unsigned char *from_start_copy = (unsigned char *) from_start;
 208
 209   codecvt->__cd_out.__cd.__data[0].__outbuf = (unsigned char *) to_start;
 210   codecvt->__cd_out.__cd.__data[0].__outbufend = (unsigned char *) to_end;
 211   codecvt->__cd_out.__cd.__data[0].__statep = statep;
 212
 213   __gconv_fct fct = gs->__fct;
 214 #ifdef PTR_DEMANGLE
 215   if (gs->__shlib_handle != NULL)
 216     PTR_DEMANGLE (fct);
 217 #endif
 218
 219   status = DL_CALL_FCT (fct,
 220                         (gs, codecvt->__cd_out.__cd.__data, &from_start_copy,
 221                          (const unsigned char *) from_end, NULL,
 222                          &dummy, 0, 0));
 223
 224   *from_stop = (wchar_t *) from_start_copy;
 225   *to_stop = (char *) codecvt->__cd_out.__cd.__data[0].__outbuf;
 226
 227   switch (status)
 228     {
 229     case __GCONV_OK:
 230     case __GCONV_EMPTY_INPUT:
 231       result = __codecvt_ok;
 232       break;
 233
 234     case __GCONV_FULL_OUTPUT:
 235     case __GCONV_INCOMPLETE_INPUT:
 236       result = __codecvt_partial;
 237       break;
 238
 239     default:
 240       result = __codecvt_error;
 241       break;
 242     }
 243 #else
 244 # ifdef _GLIBCPP_USE_WCHAR_T
 245   size_t res;
 246   const char *from_start_copy = (const char *) from_start;
 247   size_t from_len = from_end - from_start;
 248   char *to_start_copy = to_start;
 249   size_t to_len = to_end - to_start;
 250   res = iconv (codecvt->__cd_out, &from_start_copy, &from_len,
 251                &to_start_copy, &to_len);
 252
 253   if (res == 0 || from_len == 0)
 254     result = __codecvt_ok;
 255   else if (to_len < codecvt->__codecvt_do_max_length (codecvt))
 256     result = __codecvt_partial;
 257   else
 258     result = __codecvt_error;
 259
 260 # else
 261   /* Decide what to do.  */
 262   result = __codecvt_error;
 263 # endif
 264 #endif
 265
 266   return result;
 267 }
 268
 269
 270 static enum __codecvt_result
 271 do_unshift (struct _IO_codecvt *codecvt, __mbstate_t *statep,
 272             char *to_start, char *to_end, char **to_stop)
 273 {
 274   enum __codecvt_result result;
 275
 276 #ifdef _LIBC
 277   struct __gconv_step *gs = codecvt->__cd_out.__cd.__steps;
 278   int status;
 279   size_t dummy;
 280
 281   codecvt->__cd_out.__cd.__data[0].__outbuf = (unsigned char *) to_start;
 282   codecvt->__cd_out.__cd.__data[0].__outbufend = (unsigned char *) to_end;
 283   codecvt->__cd_out.__cd.__data[0].__statep = statep;
 284
 285   __gconv_fct fct = gs->__fct;
 286 #ifdef PTR_DEMANGLE
 287   if (gs->__shlib_handle != NULL)
 288     PTR_DEMANGLE (fct);
 289 #endif
 290
 291   status = DL_CALL_FCT (fct,
 292                         (gs, codecvt->__cd_out.__cd.__data, NULL, NULL,
 293                          NULL, &dummy, 1, 0));
 294
 295   *to_stop = (char *) codecvt->__cd_out.__cd.__data[0].__outbuf;
 296
 297   switch (status)
 298     {
 299     case __GCONV_OK:
 300     case __GCONV_EMPTY_INPUT:
 301       result = __codecvt_ok;
 302       break;
 303
 304     case __GCONV_FULL_OUTPUT:
 305     case __GCONV_INCOMPLETE_INPUT:
 306       result = __codecvt_partial;
 307       break;
 308
 309     default:
 310       result = __codecvt_error;
 311       break;
 312     }
 313 #else
 314 # ifdef _GLIBCPP_USE_WCHAR_T
 315   size_t res;
 316   char *to_start_copy = (char *) to_start;
 317   size_t to_len = to_end - to_start;
 318
 319   res = iconv (codecvt->__cd_out, NULL, NULL, &to_start_copy, &to_len);
 320
 321   if (res == 0)
 322     result = __codecvt_ok;
 323   else if (to_len < codecvt->__codecvt_do_max_length (codecvt))
 324     result = __codecvt_partial;
 325   else
 326     result = __codecvt_error;
 327 # else
 328   /* Decide what to do.  */
 329   result = __codecvt_error;
 330 # endif
 331 #endif
 332
 333   return result;
 334 }
 335
 336
 337 static enum __codecvt_result
 338 do_in (struct _IO_codecvt *codecvt, __mbstate_t *statep,
 339        const char *from_start, const char *from_end, const char **from_stop,
 340        wchar_t *to_start, wchar_t *to_end, wchar_t **to_stop)
 341 {
 342   enum __codecvt_result result;
 343
 344 #ifdef _LIBC
 345   struct __gconv_step *gs = codecvt->__cd_in.__cd.__steps;
 346   int status;
 347   size_t dummy;
 348   const unsigned char *from_start_copy = (unsigned char *) from_start;
 349
 350   codecvt->__cd_in.__cd.__data[0].__outbuf = (unsigned char *) to_start;
 351   codecvt->__cd_in.__cd.__data[0].__outbufend = (unsigned char *) to_end;
 352   codecvt->__cd_in.__cd.__data[0].__statep = statep;
 353
 354   __gconv_fct fct = gs->__fct;
 355 #ifdef PTR_DEMANGLE
 356   if (gs->__shlib_handle != NULL)
 357     PTR_DEMANGLE (fct);
 358 #endif
 359
 360   status = DL_CALL_FCT (fct,
 361                         (gs, codecvt->__cd_in.__cd.__data, &from_start_copy,
 362                          (const unsigned char *) from_end, NULL,
 363                          &dummy, 0, 0));
 364
 365   *from_stop = (const char *) from_start_copy;
 366   *to_stop = (wchar_t *) codecvt->__cd_in.__cd.__data[0].__outbuf;
 367
 368   switch (status)
 369     {
 370     case __GCONV_OK:
 371     case __GCONV_EMPTY_INPUT:
 372       result = __codecvt_ok;
 373       break;
 374
 375     case __GCONV_FULL_OUTPUT:
 376     case __GCONV_INCOMPLETE_INPUT:
 377       result = __codecvt_partial;
 378       break;
 379
 380     default:
 381       result = __codecvt_error;
 382       break;
 383     }
 384 #else
 385 # ifdef _GLIBCPP_USE_WCHAR_T
 386   size_t res;
 387   const char *from_start_copy = (const char *) from_start;
 388   size_t from_len = from_end - from_start;
 389   char *to_start_copy = (char *) from_start;
 390   size_t to_len = to_end - to_start;
 391
 392   res = iconv (codecvt->__cd_in, &from_start_copy, &from_len,
 393                &to_start_copy, &to_len);
 394
 395   if (res == 0)
 396     result = __codecvt_ok;
 397   else if (to_len == 0)
 398     result = __codecvt_partial;
 399   else if (from_len < codecvt->__codecvt_do_max_length (codecvt))
 400     result = __codecvt_partial;
 401   else
 402     result = __codecvt_error;
 403 # else
 404   /* Decide what to do.  */
 405   result = __codecvt_error;
 406 # endif
 407 #endif
 408
 409   return result;
 410 }
 411
 412
 413 static int
 414 do_encoding (struct _IO_codecvt *codecvt)
 415 {
 416 #ifdef _LIBC
 417   /* See whether the encoding is stateful.  */
 418   if (codecvt->__cd_in.__cd.__steps[0].__stateful)
 419     return -1;
 420   /* Fortunately not.  Now determine the input bytes for the conversion
 421      necessary for each wide character.  */
 422   if (codecvt->__cd_in.__cd.__steps[0].__min_needed_from
 423       != codecvt->__cd_in.__cd.__steps[0].__max_needed_from)
 424     /* Not a constant value.  */
 425     return 0;
 426
 427   return codecvt->__cd_in.__cd.__steps[0].__min_needed_from;
 428 #else
 429   /* Worst case scenario.  */
 430   return -1;
 431 #endif
 432 }
 433
 434
 435 static int
 436 do_always_noconv (struct _IO_codecvt *codecvt)
 437 {
 438   return 0;
 439 }
 440
 441
 442 static int
 443 do_length (struct _IO_codecvt *codecvt, __mbstate_t *statep,
 444            const char *from_start, const char *from_end, _IO_size_t max)
 445 {
 446   int result;
 447 #ifdef _LIBC
 448   const unsigned char *cp = (const unsigned char *) from_start;
 449   wchar_t to_buf[max];
 450   struct __gconv_step *gs = codecvt->__cd_in.__cd.__steps;
 451   size_t dummy;
 452
 453   codecvt->__cd_in.__cd.__data[0].__outbuf = (unsigned char *) to_buf;
 454   codecvt->__cd_in.__cd.__data[0].__outbufend = (unsigned char *) &to_buf[max];
 455   codecvt->__cd_in.__cd.__data[0].__statep = statep;
 456
 457   __gconv_fct fct = gs->__fct;
 458 #ifdef PTR_DEMANGLE
 459   if (gs->__shlib_handle != NULL)
 460     PTR_DEMANGLE (fct);
 461 #endif
 462
 463   DL_CALL_FCT (fct,
 464                (gs, codecvt->__cd_in.__cd.__data, &cp,
 465                 (const unsigned char *) from_end, NULL,
 466                 &dummy, 0, 0));
 467
 468   result = cp - (const unsigned char *) from_start;
 469 #else
 470 # ifdef _GLIBCPP_USE_WCHAR_T
 471   const char *from_start_copy = (const char *) from_start;
 472   size_t from_len = from_end - from_start;
 473   wchar_t to_buf[max];
 474   size_t res;
 475   char *to_start = (char *) to_buf;
 476
 477   res = iconv (codecvt->__cd_in, &from_start_copy, &from_len,
 478                &to_start, &max);
 479
 480   result = from_start_copy - (char *) from_start;
 481 # else
 482   /* Decide what to do.  */
 483   result = 0;
 484 # endif
 485 #endif
 486
 487   return result;
 488 }
 489
 490
 491 static int
 492 do_max_length (struct _IO_codecvt *codecvt)
 493 {
 494 #ifdef _LIBC
 495   return codecvt->__cd_in.__cd.__steps[0].__max_needed_from;
 496 #else
 497   return MB_CUR_MAX;
 498 #endif
 499 }