Print this page
2964 need POSIX 2008 locale object support
Reviewed by: Robert Mustacchi <rm@joyent.com>
Reviewed by: Gordon Ross <gordon.ross@nexenta.com>
Approved by: TBD

Split Close
Expand all
Collapse all
          --- old/usr/src/lib/libc/port/locale/euc.c
          +++ new/usr/src/lib/libc/port/locale/euc.c
   1    1  /*
        2 + * Copyright 2013 Garrett D'Amore <garrett@damore.org>
   2    3   * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
   3    4   * Copyright (c) 2002-2004 Tim J. Robbins. All rights reserved.
   4    5   * Copyright (c) 1993
   5    6   *      The Regents of the University of California.  All rights reserved.
   6    7   *
   7    8   * This code is derived from software contributed to Berkeley by
   8    9   * Paul Borman at Krystal Technologies.
   9   10   *
  10   11   * Redistribution and use in source and binary forms, with or without
  11   12   * modification, are permitted provided that the following conditions
↓ open down ↓ 21 lines elided ↑ open up ↑
  33   34   */
  34   35  
  35   36  #include "lint.h"
  36   37  #include <errno.h>
  37   38  #include <limits.h>
  38   39  #include <stdlib.h>
  39   40  #include <string.h>
  40   41  #include <wchar.h>
  41   42  #include <sys/types.h>
  42   43  #include <sys/euc.h>
  43      -#include "runetype.h"
  44   44  #include "mblocal.h"
       45 +#include "lctype.h"
  45   46  
  46   47  static size_t   _EUC_mbrtowc_impl(wchar_t *_RESTRICT_KYWD,
  47   48      const char *_RESTRICT_KYWD,
  48   49      size_t, mbstate_t *_RESTRICT_KYWD, uint8_t, uint8_t, uint8_t, uint8_t);
  49   50  static size_t   _EUC_wcrtomb_impl(char *_RESTRICT_KYWD, wchar_t,
  50   51      mbstate_t *_RESTRICT_KYWD, uint8_t, uint8_t, uint8_t, uint8_t);
  51   52  
  52   53  static size_t   _EUC_CN_mbrtowc(wchar_t *_RESTRICT_KYWD,
  53   54                      const char *_RESTRICT_KYWD,
  54   55                      size_t, mbstate_t *_RESTRICT_KYWD);
  55   56  static size_t   _EUC_JP_mbrtowc(wchar_t *_RESTRICT_KYWD,
  56   57                      const char *_RESTRICT_KYWD,
  57   58                      size_t, mbstate_t *_RESTRICT_KYWD);
  58   59  static size_t   _EUC_KR_mbrtowc(wchar_t *_RESTRICT_KYWD,
  59   60                      const char *_RESTRICT_KYWD,
  60   61                      size_t, mbstate_t *_RESTRICT_KYWD);
  61   62  static size_t   _EUC_TW_mbrtowc(wchar_t *_RESTRICT_KYWD,
  62   63                      const char *_RESTRICT_KYWD,
  63   64                      size_t, mbstate_t *_RESTRICT_KYWD);
       65 +
  64   66  static size_t   _EUC_CN_wcrtomb(char *_RESTRICT_KYWD, wchar_t,
  65   67                      mbstate_t *_RESTRICT_KYWD);
  66   68  static size_t   _EUC_JP_wcrtomb(char *_RESTRICT_KYWD, wchar_t,
  67   69                      mbstate_t *_RESTRICT_KYWD);
  68   70  static size_t   _EUC_KR_wcrtomb(char *_RESTRICT_KYWD, wchar_t,
  69   71                      mbstate_t *_RESTRICT_KYWD);
  70   72  static size_t   _EUC_TW_wcrtomb(char *_RESTRICT_KYWD, wchar_t,
  71   73                      mbstate_t *_RESTRICT_KYWD);
       74 +
       75 +static size_t   _EUC_CN_mbsnrtowcs(wchar_t *_RESTRICT_KYWD,
       76 +                    const char **_RESTRICT_KYWD, size_t, size_t,
       77 +                    mbstate_t *_RESTRICT_KYWD);
       78 +static size_t   _EUC_JP_mbsnrtowcs(wchar_t *_RESTRICT_KYWD,
       79 +                    const char **_RESTRICT_KYWD, size_t, size_t,
       80 +                    mbstate_t *_RESTRICT_KYWD);
       81 +static size_t   _EUC_KR_mbsnrtowcs(wchar_t *_RESTRICT_KYWD,
       82 +                    const char **_RESTRICT_KYWD, size_t, size_t,
       83 +                    mbstate_t *_RESTRICT_KYWD);
       84 +static size_t   _EUC_TW_mbsnrtowcs(wchar_t *_RESTRICT_KYWD,
       85 +                    const char **_RESTRICT_KYWD, size_t, size_t,
       86 +                    mbstate_t *_RESTRICT_KYWD);
       87 +
       88 +static size_t   _EUC_CN_wcsnrtombs(char *_RESTRICT_KYWD,
       89 +                    const wchar_t **_RESTRICT_KYWD, size_t, size_t,
       90 +                    mbstate_t *_RESTRICT_KYWD);
       91 +static size_t   _EUC_JP_wcsnrtombs(char *_RESTRICT_KYWD,
       92 +                    const wchar_t **_RESTRICT_KYWD, size_t, size_t,
       93 +                    mbstate_t *_RESTRICT_KYWD);
       94 +static size_t   _EUC_KR_wcsnrtombs(char *_RESTRICT_KYWD,
       95 +                    const wchar_t **_RESTRICT_KYWD, size_t, size_t,
       96 +                    mbstate_t *_RESTRICT_KYWD);
       97 +static size_t   _EUC_TW_wcsnrtombs(char *_RESTRICT_KYWD,
       98 +                    const wchar_t **_RESTRICT_KYWD, size_t, size_t,
       99 +                    mbstate_t *_RESTRICT_KYWD);
      100 +
  72  101  static int      _EUC_mbsinit(const mbstate_t *);
  73  102  
  74  103  typedef struct {
  75  104          wchar_t ch;
  76  105          int     set;
  77  106          int     want;
  78  107  } _EucState;
  79  108  
  80      -static int
      109 +int
  81  110  _EUC_mbsinit(const mbstate_t *ps)
  82  111  {
  83  112  
  84  113          return (ps == NULL || ((const _EucState *)ps)->want == 0);
  85  114  }
  86  115  
  87  116  /*
  88  117   * EUC-CN uses CS0, CS1 and CS2 (4 bytes).
  89  118   */
  90      -int
  91      -_EUC_CN_init(_RuneLocale *rl)
      119 +void
      120 +_EUC_CN_init(struct lc_ctype *lct)
  92  121  {
  93      -        __mbrtowc = _EUC_CN_mbrtowc;
  94      -        __wcrtomb = _EUC_CN_wcrtomb;
  95      -        __mbsinit = _EUC_mbsinit;
      122 +        lct->lc_mbrtowc = _EUC_CN_mbrtowc;
      123 +        lct->lc_wcrtomb = _EUC_CN_wcrtomb;
      124 +        lct->lc_mbsnrtowcs = _EUC_CN_mbsnrtowcs;
      125 +        lct->lc_wcsnrtombs = _EUC_CN_wcsnrtombs;
      126 +        lct->lc_mbsinit = _EUC_mbsinit;
  96  127  
  97      -        _CurrentRuneLocale = rl;
  98      -
  99      -        __ctype[520] = 4;
 100      -        charset_is_ascii = 0;
 101      -        return (0);
      128 +        lct->lc_max_mblen = 4;
      129 +        lct->lc_is_ascii = 0;
 102  130  }
 103  131  
 104  132  static size_t
 105  133  _EUC_CN_mbrtowc(wchar_t *_RESTRICT_KYWD pwc, const char *_RESTRICT_KYWD s,
 106  134      size_t n, mbstate_t *_RESTRICT_KYWD ps)
 107  135  {
 108  136          return (_EUC_mbrtowc_impl(pwc, s, n, ps, SS2, 4, 0, 0));
 109  137  }
 110  138  
 111  139  static size_t
      140 +_EUC_CN_mbsnrtowcs(wchar_t *_RESTRICT_KYWD dst,
      141 +    const char **_RESTRICT_KYWD src,
      142 +    size_t nms, size_t len, mbstate_t *_RESTRICT_KYWD ps)
      143 +{
      144 +        return (__mbsnrtowcs_std(dst, src, nms, len, ps, _EUC_CN_mbrtowc));
      145 +}
      146 +
      147 +static size_t
 112  148  _EUC_CN_wcrtomb(char *_RESTRICT_KYWD s, wchar_t wc,
 113  149      mbstate_t *_RESTRICT_KYWD ps)
 114  150  {
 115  151          return (_EUC_wcrtomb_impl(s, wc, ps, SS2, 4, 0, 0));
 116  152  }
 117  153  
      154 +static size_t
      155 +_EUC_CN_wcsnrtombs(char *_RESTRICT_KYWD dst, const wchar_t **_RESTRICT_KYWD src,
      156 +        size_t nwc, size_t len, mbstate_t *_RESTRICT_KYWD ps)
      157 +{
      158 +        return (__wcsnrtombs_std(dst, src, nwc, len, ps, _EUC_CN_wcrtomb));
      159 +}
      160 +
 118  161  /*
 119  162   * EUC-KR uses only CS0 and CS1.
 120  163   */
 121      -int
 122      -_EUC_KR_init(_RuneLocale *rl)
      164 +void
      165 +_EUC_KR_init(struct lc_ctype *lct)
 123  166  {
 124      -        __mbrtowc = _EUC_KR_mbrtowc;
 125      -        __wcrtomb = _EUC_KR_wcrtomb;
 126      -        __mbsinit = _EUC_mbsinit;
      167 +        lct->lc_mbrtowc = _EUC_KR_mbrtowc;
      168 +        lct->lc_wcrtomb = _EUC_KR_wcrtomb;
      169 +        lct->lc_mbsnrtowcs = _EUC_KR_mbsnrtowcs;
      170 +        lct->lc_wcsnrtombs = _EUC_KR_wcsnrtombs;
      171 +        lct->lc_mbsinit = _EUC_mbsinit;
 127  172  
 128      -        _CurrentRuneLocale = rl;
 129      -
 130      -        __ctype[520] = 2;
 131      -        charset_is_ascii = 0;
 132      -        return (0);
      173 +        lct->lc_max_mblen = 2;
      174 +        lct->lc_is_ascii = 0;
 133  175  }
 134  176  
 135  177  static size_t
 136  178  _EUC_KR_mbrtowc(wchar_t *_RESTRICT_KYWD pwc, const char *_RESTRICT_KYWD s,
 137  179      size_t n, mbstate_t *_RESTRICT_KYWD ps)
 138  180  {
 139  181          return (_EUC_mbrtowc_impl(pwc, s, n, ps, 0, 0, 0, 0));
 140  182  }
 141  183  
 142  184  static size_t
      185 +_EUC_KR_mbsnrtowcs(wchar_t *_RESTRICT_KYWD dst,
      186 +    const char **_RESTRICT_KYWD src,
      187 +    size_t nms, size_t len, mbstate_t *_RESTRICT_KYWD ps)
      188 +{
      189 +        return (__mbsnrtowcs_std(dst, src, nms, len, ps, _EUC_KR_mbrtowc));
      190 +}
      191 +
      192 +static size_t
 143  193  _EUC_KR_wcrtomb(char *_RESTRICT_KYWD s, wchar_t wc,
 144      -    mbstate_t *_RESTRICT_KYWD ps)
      194 +        mbstate_t *_RESTRICT_KYWD ps)
 145  195  {
 146  196          return (_EUC_wcrtomb_impl(s, wc, ps, 0, 0, 0, 0));
 147  197  }
 148  198  
      199 +static size_t
      200 +_EUC_KR_wcsnrtombs(char *_RESTRICT_KYWD dst, const wchar_t **_RESTRICT_KYWD src,
      201 +        size_t nwc, size_t len, mbstate_t *_RESTRICT_KYWD ps)
      202 +{
      203 +        return (__wcsnrtombs_std(dst, src, nwc, len, ps, _EUC_KR_wcrtomb));
      204 +}
      205 +
 149  206  /*
 150  207   * EUC-JP uses CS0, CS1, CS2, and CS3.
 151  208   */
 152      -int
 153      -_EUC_JP_init(_RuneLocale *rl)
      209 +void
      210 +_EUC_JP_init(struct lc_ctype *lct)
 154  211  {
 155      -        __mbrtowc = _EUC_JP_mbrtowc;
 156      -        __wcrtomb = _EUC_JP_wcrtomb;
 157      -        __mbsinit = _EUC_mbsinit;
      212 +        lct->lc_mbrtowc = _EUC_JP_mbrtowc;
      213 +        lct->lc_wcrtomb = _EUC_JP_wcrtomb;
      214 +        lct->lc_mbsnrtowcs = _EUC_JP_mbsnrtowcs;
      215 +        lct->lc_wcsnrtombs = _EUC_JP_wcsnrtombs;
      216 +        lct->lc_mbsinit = _EUC_mbsinit;
 158  217  
 159      -        _CurrentRuneLocale = rl;
 160      -
 161      -        __ctype[520] = 3;
 162      -        charset_is_ascii = 0;
 163      -        return (0);
      218 +        lct->lc_max_mblen = 3;
      219 +        lct->lc_is_ascii = 0;
 164  220  }
 165  221  
 166  222  static size_t
 167  223  _EUC_JP_mbrtowc(wchar_t *_RESTRICT_KYWD pwc, const char *_RESTRICT_KYWD s,
 168  224      size_t n, mbstate_t *_RESTRICT_KYWD ps)
 169  225  {
 170  226          return (_EUC_mbrtowc_impl(pwc, s, n, ps, SS2, 2, SS3, 3));
 171  227  }
 172  228  
 173  229  static size_t
      230 +_EUC_JP_mbsnrtowcs(wchar_t *_RESTRICT_KYWD dst,
      231 +    const char **_RESTRICT_KYWD src,
      232 +    size_t nms, size_t len, mbstate_t *_RESTRICT_KYWD ps)
      233 +{
      234 +        return (__mbsnrtowcs_std(dst, src, nms, len, ps, _EUC_JP_mbrtowc));
      235 +}
      236 +
      237 +static size_t
 174  238  _EUC_JP_wcrtomb(char *_RESTRICT_KYWD s, wchar_t wc,
 175  239      mbstate_t *_RESTRICT_KYWD ps)
 176  240  {
 177  241          return (_EUC_wcrtomb_impl(s, wc, ps, SS2, 2, SS3, 3));
 178  242  }
 179  243  
      244 +static size_t
      245 +_EUC_JP_wcsnrtombs(char *_RESTRICT_KYWD dst, const wchar_t **_RESTRICT_KYWD src,
      246 +        size_t nwc, size_t len, mbstate_t *_RESTRICT_KYWD ps)
      247 +{
      248 +        return (__wcsnrtombs_std(dst, src, nwc, len, ps, _EUC_JP_wcrtomb));
      249 +}
      250 +
 180  251  /*
 181  252   * EUC-TW uses CS0, CS1, and CS2.
 182  253   */
 183      -int
 184      -_EUC_TW_init(_RuneLocale *rl)
      254 +void
      255 +_EUC_TW_init(struct lc_ctype *lct)
 185  256  {
 186      -        __mbrtowc = _EUC_TW_mbrtowc;
 187      -        __wcrtomb = _EUC_TW_wcrtomb;
 188      -        __mbsinit = _EUC_mbsinit;
      257 +        lct->lc_mbrtowc = _EUC_TW_mbrtowc;
      258 +        lct->lc_wcrtomb = _EUC_TW_wcrtomb;
      259 +        lct->lc_mbsnrtowcs = _EUC_TW_mbsnrtowcs;
      260 +        lct->lc_wcsnrtombs = _EUC_TW_wcsnrtombs;
      261 +        lct->lc_mbsinit = _EUC_mbsinit;
 189  262  
 190      -        _CurrentRuneLocale = rl;
 191      -
 192      -        __ctype[520] = 4;
 193      -        charset_is_ascii = 0;
 194      -        return (0);
      263 +        lct->lc_max_mblen = 4;
      264 +        lct->lc_is_ascii = 0;
 195  265  }
 196  266  
 197  267  static size_t
 198  268  _EUC_TW_mbrtowc(wchar_t *_RESTRICT_KYWD pwc, const char *_RESTRICT_KYWD s,
 199      -    size_t n, mbstate_t *_RESTRICT_KYWD ps)
      269 +        size_t n, mbstate_t *_RESTRICT_KYWD ps)
 200  270  {
 201  271          return (_EUC_mbrtowc_impl(pwc, s, n, ps, SS2, 4, 0, 0));
 202  272  }
 203  273  
 204  274  static size_t
      275 +_EUC_TW_mbsnrtowcs(wchar_t *_RESTRICT_KYWD dst,
      276 +        const char **_RESTRICT_KYWD src,
      277 +        size_t nms, size_t len, mbstate_t *_RESTRICT_KYWD ps)
      278 +{
      279 +        return (__mbsnrtowcs_std(dst, src, nms, len, ps, _EUC_TW_mbrtowc));
      280 +}
      281 +
      282 +static size_t
 205  283  _EUC_TW_wcrtomb(char *_RESTRICT_KYWD s, wchar_t wc,
 206      -    mbstate_t *_RESTRICT_KYWD ps)
      284 +        mbstate_t *_RESTRICT_KYWD ps)
 207  285  {
 208  286          return (_EUC_wcrtomb_impl(s, wc, ps, SS2, 4, 0, 0));
 209  287  }
 210  288  
      289 +static size_t
      290 +_EUC_TW_wcsnrtombs(char *_RESTRICT_KYWD dst, const wchar_t **_RESTRICT_KYWD src,
      291 +        size_t nwc, size_t len, mbstate_t *_RESTRICT_KYWD ps)
      292 +{
      293 +        return (__wcsnrtombs_std(dst, src, nwc, len, ps, _EUC_TW_wcrtomb));
      294 +}
      295 +
 211  296  /*
 212  297   * Common EUC code.
 213  298   */
 214  299  
 215  300  static size_t
 216  301  _EUC_mbrtowc_impl(wchar_t *_RESTRICT_KYWD pwc, const char *_RESTRICT_KYWD s,
 217      -    size_t n, mbstate_t *_RESTRICT_KYWD ps,
 218      -    uint8_t cs2, uint8_t cs2width, uint8_t cs3, uint8_t cs3width)
      302 +        size_t n, mbstate_t *_RESTRICT_KYWD ps,
      303 +        uint8_t cs2, uint8_t cs2width, uint8_t cs3, uint8_t cs3width)
 219  304  {
 220  305          _EucState *es;
 221  306          int i, want;
 222  307          wchar_t wc;
 223  308          unsigned char ch;
 224  309  
 225  310          es = (_EucState *)ps;
 226  311  
 227  312          if (es->want < 0 || es->want > MB_CUR_MAX) {
 228  313                  errno = EINVAL;
↓ open down ↓ 127 lines elided ↑ open up ↑
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX