Print this page
2964 need POSIX 2008 locale object support
Reviewed by: Robert Mustacchi <rm@joyent.com>
   1 /*

   2  * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
   3  * Copyright (c) 2002-2004 Tim J. Robbins. All rights reserved.
   4  * Copyright (c) 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * This code is derived from software contributed to Berkeley by
   8  * Paul Borman at Krystal Technologies.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  * 4. Neither the name of the University nor the names of its contributors
  19  *    may be used to endorse or promote products derived from this software
  20  *    without specific prior written permission.
  21  *


  23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  */
  34 
  35 #include "lint.h"
  36 #include <errno.h>
  37 #include <limits.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <wchar.h>
  41 #include <sys/types.h>
  42 #include <sys/euc.h>
  43 #include "runetype.h"
  44 #include "mblocal.h"

  45 
  46 static size_t   _EUC_mbrtowc_impl(wchar_t *_RESTRICT_KYWD,
  47     const char *_RESTRICT_KYWD,
  48     size_t, mbstate_t *_RESTRICT_KYWD, uint8_t, uint8_t, uint8_t, uint8_t);
  49 static size_t   _EUC_wcrtomb_impl(char *_RESTRICT_KYWD, wchar_t,
  50     mbstate_t *_RESTRICT_KYWD, uint8_t, uint8_t, uint8_t, uint8_t);
  51 
  52 static size_t   _EUC_CN_mbrtowc(wchar_t *_RESTRICT_KYWD,
  53                     const char *_RESTRICT_KYWD,
  54                     size_t, mbstate_t *_RESTRICT_KYWD);
  55 static size_t   _EUC_JP_mbrtowc(wchar_t *_RESTRICT_KYWD,
  56                     const char *_RESTRICT_KYWD,
  57                     size_t, mbstate_t *_RESTRICT_KYWD);
  58 static size_t   _EUC_KR_mbrtowc(wchar_t *_RESTRICT_KYWD,
  59                     const char *_RESTRICT_KYWD,
  60                     size_t, mbstate_t *_RESTRICT_KYWD);
  61 static size_t   _EUC_TW_mbrtowc(wchar_t *_RESTRICT_KYWD,
  62                     const char *_RESTRICT_KYWD,
  63                     size_t, mbstate_t *_RESTRICT_KYWD);

  64 static size_t   _EUC_CN_wcrtomb(char *_RESTRICT_KYWD, wchar_t,
  65                     mbstate_t *_RESTRICT_KYWD);
  66 static size_t   _EUC_JP_wcrtomb(char *_RESTRICT_KYWD, wchar_t,
  67                     mbstate_t *_RESTRICT_KYWD);
  68 static size_t   _EUC_KR_wcrtomb(char *_RESTRICT_KYWD, wchar_t,
  69                     mbstate_t *_RESTRICT_KYWD);
  70 static size_t   _EUC_TW_wcrtomb(char *_RESTRICT_KYWD, wchar_t,
  71                     mbstate_t *_RESTRICT_KYWD);



























  72 static int      _EUC_mbsinit(const mbstate_t *);
  73 
  74 typedef struct {
  75         wchar_t ch;
  76         int     set;
  77         int     want;
  78 } _EucState;
  79 
  80 static int
  81 _EUC_mbsinit(const mbstate_t *ps)
  82 {
  83 
  84         return (ps == NULL || ((const _EucState *)ps)->want == 0);
  85 }
  86 
  87 /*
  88  * EUC-CN uses CS0, CS1 and CS2 (4 bytes).
  89  */
  90 int
  91 _EUC_CN_init(_RuneLocale *rl)
  92 {
  93         __mbrtowc = _EUC_CN_mbrtowc;
  94         __wcrtomb = _EUC_CN_wcrtomb;
  95         __mbsinit = _EUC_mbsinit;


  96 
  97         _CurrentRuneLocale = rl;
  98 
  99         __ctype[520] = 4;
 100         charset_is_ascii = 0;
 101         return (0);
 102 }
 103 
 104 static size_t
 105 _EUC_CN_mbrtowc(wchar_t *_RESTRICT_KYWD pwc, const char *_RESTRICT_KYWD s,
 106     size_t n, mbstate_t *_RESTRICT_KYWD ps)
 107 {
 108         return (_EUC_mbrtowc_impl(pwc, s, n, ps, SS2, 4, 0, 0));
 109 }
 110 
 111 static size_t








 112 _EUC_CN_wcrtomb(char *_RESTRICT_KYWD s, wchar_t wc,
 113     mbstate_t *_RESTRICT_KYWD ps)
 114 {
 115         return (_EUC_wcrtomb_impl(s, wc, ps, SS2, 4, 0, 0));
 116 }
 117 







 118 /*
 119  * EUC-KR uses only CS0 and CS1.
 120  */
 121 int
 122 _EUC_KR_init(_RuneLocale *rl)
 123 {
 124         __mbrtowc = _EUC_KR_mbrtowc;
 125         __wcrtomb = _EUC_KR_wcrtomb;
 126         __mbsinit = _EUC_mbsinit;


 127 
 128         _CurrentRuneLocale = rl;
 129 
 130         __ctype[520] = 2;
 131         charset_is_ascii = 0;
 132         return (0);
 133 }
 134 
 135 static size_t
 136 _EUC_KR_mbrtowc(wchar_t *_RESTRICT_KYWD pwc, const char *_RESTRICT_KYWD s,
 137     size_t n, mbstate_t *_RESTRICT_KYWD ps)
 138 {
 139         return (_EUC_mbrtowc_impl(pwc, s, n, ps, 0, 0, 0, 0));
 140 }
 141 
 142 static size_t








 143 _EUC_KR_wcrtomb(char *_RESTRICT_KYWD s, wchar_t wc,
 144     mbstate_t *_RESTRICT_KYWD ps)
 145 {
 146         return (_EUC_wcrtomb_impl(s, wc, ps, 0, 0, 0, 0));
 147 }
 148 







 149 /*
 150  * EUC-JP uses CS0, CS1, CS2, and CS3.
 151  */
 152 int
 153 _EUC_JP_init(_RuneLocale *rl)
 154 {
 155         __mbrtowc = _EUC_JP_mbrtowc;
 156         __wcrtomb = _EUC_JP_wcrtomb;
 157         __mbsinit = _EUC_mbsinit;


 158 
 159         _CurrentRuneLocale = rl;
 160 
 161         __ctype[520] = 3;
 162         charset_is_ascii = 0;
 163         return (0);
 164 }
 165 
 166 static size_t
 167 _EUC_JP_mbrtowc(wchar_t *_RESTRICT_KYWD pwc, const char *_RESTRICT_KYWD s,
 168     size_t n, mbstate_t *_RESTRICT_KYWD ps)
 169 {
 170         return (_EUC_mbrtowc_impl(pwc, s, n, ps, SS2, 2, SS3, 3));
 171 }
 172 
 173 static size_t








 174 _EUC_JP_wcrtomb(char *_RESTRICT_KYWD s, wchar_t wc,
 175     mbstate_t *_RESTRICT_KYWD ps)
 176 {
 177         return (_EUC_wcrtomb_impl(s, wc, ps, SS2, 2, SS3, 3));
 178 }
 179 







 180 /*
 181  * EUC-TW uses CS0, CS1, and CS2.
 182  */
 183 int
 184 _EUC_TW_init(_RuneLocale *rl)
 185 {
 186         __mbrtowc = _EUC_TW_mbrtowc;
 187         __wcrtomb = _EUC_TW_wcrtomb;
 188         __mbsinit = _EUC_mbsinit;


 189 
 190         _CurrentRuneLocale = rl;
 191 
 192         __ctype[520] = 4;
 193         charset_is_ascii = 0;
 194         return (0);
 195 }
 196 
 197 static size_t
 198 _EUC_TW_mbrtowc(wchar_t *_RESTRICT_KYWD pwc, const char *_RESTRICT_KYWD s,
 199     size_t n, mbstate_t *_RESTRICT_KYWD ps)
 200 {
 201         return (_EUC_mbrtowc_impl(pwc, s, n, ps, SS2, 4, 0, 0));
 202 }
 203 
 204 static size_t








 205 _EUC_TW_wcrtomb(char *_RESTRICT_KYWD s, wchar_t wc,
 206     mbstate_t *_RESTRICT_KYWD ps)
 207 {
 208         return (_EUC_wcrtomb_impl(s, wc, ps, SS2, 4, 0, 0));
 209 }
 210 







 211 /*
 212  * Common EUC code.
 213  */
 214 
 215 static size_t
 216 _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)
 219 {
 220         _EucState *es;
 221         int i, want;
 222         wchar_t wc;
 223         unsigned char ch;
 224 
 225         es = (_EucState *)ps;
 226 
 227         if (es->want < 0 || es->want > MB_CUR_MAX) {
 228                 errno = EINVAL;
 229                 return ((size_t)-1);
 230         }


   1 /*
   2  * Copyright 2013 Garrett D'Amore <garrett@damore.org>
   3  * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
   4  * Copyright (c) 2002-2004 Tim J. Robbins. All rights reserved.
   5  * Copyright (c) 1993
   6  *      The Regents of the University of California.  All rights reserved.
   7  *
   8  * This code is derived from software contributed to Berkeley by
   9  * Paul Borman at Krystal Technologies.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer.
  16  * 2. Redistributions in binary form must reproduce the above copyright
  17  *    notice, this list of conditions and the following disclaimer in the
  18  *    documentation and/or other materials provided with the distribution.
  19  * 4. Neither the name of the University nor the names of its contributors
  20  *    may be used to endorse or promote products derived from this software
  21  *    without specific prior written permission.
  22  *


  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35 
  36 #include "lint.h"
  37 #include <errno.h>
  38 #include <limits.h>
  39 #include <stdlib.h>
  40 #include <string.h>
  41 #include <wchar.h>
  42 #include <sys/types.h>
  43 #include <sys/euc.h>

  44 #include "mblocal.h"
  45 #include "lctype.h"
  46 
  47 static size_t   _EUC_mbrtowc_impl(wchar_t *_RESTRICT_KYWD,
  48     const char *_RESTRICT_KYWD,
  49     size_t, mbstate_t *_RESTRICT_KYWD, uint8_t, uint8_t, uint8_t, uint8_t);
  50 static size_t   _EUC_wcrtomb_impl(char *_RESTRICT_KYWD, wchar_t,
  51     mbstate_t *_RESTRICT_KYWD, uint8_t, uint8_t, uint8_t, uint8_t);
  52 
  53 static size_t   _EUC_CN_mbrtowc(wchar_t *_RESTRICT_KYWD,
  54                     const char *_RESTRICT_KYWD,
  55                     size_t, mbstate_t *_RESTRICT_KYWD);
  56 static size_t   _EUC_JP_mbrtowc(wchar_t *_RESTRICT_KYWD,
  57                     const char *_RESTRICT_KYWD,
  58                     size_t, mbstate_t *_RESTRICT_KYWD);
  59 static size_t   _EUC_KR_mbrtowc(wchar_t *_RESTRICT_KYWD,
  60                     const char *_RESTRICT_KYWD,
  61                     size_t, mbstate_t *_RESTRICT_KYWD);
  62 static size_t   _EUC_TW_mbrtowc(wchar_t *_RESTRICT_KYWD,
  63                     const char *_RESTRICT_KYWD,
  64                     size_t, mbstate_t *_RESTRICT_KYWD);
  65 
  66 static size_t   _EUC_CN_wcrtomb(char *_RESTRICT_KYWD, wchar_t,
  67                     mbstate_t *_RESTRICT_KYWD);
  68 static size_t   _EUC_JP_wcrtomb(char *_RESTRICT_KYWD, wchar_t,
  69                     mbstate_t *_RESTRICT_KYWD);
  70 static size_t   _EUC_KR_wcrtomb(char *_RESTRICT_KYWD, wchar_t,
  71                     mbstate_t *_RESTRICT_KYWD);
  72 static size_t   _EUC_TW_wcrtomb(char *_RESTRICT_KYWD, wchar_t,
  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 
 101 static int      _EUC_mbsinit(const mbstate_t *);
 102 
 103 typedef struct {
 104         wchar_t ch;
 105         int     set;
 106         int     want;
 107 } _EucState;
 108 
 109 int
 110 _EUC_mbsinit(const mbstate_t *ps)
 111 {
 112 
 113         return (ps == NULL || ((const _EucState *)ps)->want == 0);
 114 }
 115 
 116 /*
 117  * EUC-CN uses CS0, CS1 and CS2 (4 bytes).
 118  */
 119 void
 120 _EUC_CN_init(struct lc_ctype *lct)
 121 {
 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;
 127 
 128         lct->lc_max_mblen = 4;
 129         lct->lc_is_ascii = 0;



 130 }
 131 
 132 static size_t
 133 _EUC_CN_mbrtowc(wchar_t *_RESTRICT_KYWD pwc, const char *_RESTRICT_KYWD s,
 134     size_t n, mbstate_t *_RESTRICT_KYWD ps)
 135 {
 136         return (_EUC_mbrtowc_impl(pwc, s, n, ps, SS2, 4, 0, 0));
 137 }
 138 
 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
 148 _EUC_CN_wcrtomb(char *_RESTRICT_KYWD s, wchar_t wc,
 149     mbstate_t *_RESTRICT_KYWD ps)
 150 {
 151         return (_EUC_wcrtomb_impl(s, wc, ps, SS2, 4, 0, 0));
 152 }
 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 
 161 /*
 162  * EUC-KR uses only CS0 and CS1.
 163  */
 164 void
 165 _EUC_KR_init(struct lc_ctype *lct)
 166 {
 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;
 172 
 173         lct->lc_max_mblen = 2;
 174         lct->lc_is_ascii = 0;



 175 }
 176 
 177 static size_t
 178 _EUC_KR_mbrtowc(wchar_t *_RESTRICT_KYWD pwc, const char *_RESTRICT_KYWD s,
 179     size_t n, mbstate_t *_RESTRICT_KYWD ps)
 180 {
 181         return (_EUC_mbrtowc_impl(pwc, s, n, ps, 0, 0, 0, 0));
 182 }
 183 
 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
 193 _EUC_KR_wcrtomb(char *_RESTRICT_KYWD s, wchar_t wc,
 194         mbstate_t *_RESTRICT_KYWD ps)
 195 {
 196         return (_EUC_wcrtomb_impl(s, wc, ps, 0, 0, 0, 0));
 197 }
 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 
 206 /*
 207  * EUC-JP uses CS0, CS1, CS2, and CS3.
 208  */
 209 void
 210 _EUC_JP_init(struct lc_ctype *lct)
 211 {
 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;
 217 
 218         lct->lc_max_mblen = 3;
 219         lct->lc_is_ascii = 0;



 220 }
 221 
 222 static size_t
 223 _EUC_JP_mbrtowc(wchar_t *_RESTRICT_KYWD pwc, const char *_RESTRICT_KYWD s,
 224     size_t n, mbstate_t *_RESTRICT_KYWD ps)
 225 {
 226         return (_EUC_mbrtowc_impl(pwc, s, n, ps, SS2, 2, SS3, 3));
 227 }
 228 
 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
 238 _EUC_JP_wcrtomb(char *_RESTRICT_KYWD s, wchar_t wc,
 239     mbstate_t *_RESTRICT_KYWD ps)
 240 {
 241         return (_EUC_wcrtomb_impl(s, wc, ps, SS2, 2, SS3, 3));
 242 }
 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 
 251 /*
 252  * EUC-TW uses CS0, CS1, and CS2.
 253  */
 254 void
 255 _EUC_TW_init(struct lc_ctype *lct)
 256 {
 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;
 262 
 263         lct->lc_max_mblen = 4;
 264         lct->lc_is_ascii = 0;



 265 }
 266 
 267 static size_t
 268 _EUC_TW_mbrtowc(wchar_t *_RESTRICT_KYWD pwc, const char *_RESTRICT_KYWD s,
 269         size_t n, mbstate_t *_RESTRICT_KYWD ps)
 270 {
 271         return (_EUC_mbrtowc_impl(pwc, s, n, ps, SS2, 4, 0, 0));
 272 }
 273 
 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
 283 _EUC_TW_wcrtomb(char *_RESTRICT_KYWD s, wchar_t wc,
 284         mbstate_t *_RESTRICT_KYWD ps)
 285 {
 286         return (_EUC_wcrtomb_impl(s, wc, ps, SS2, 4, 0, 0));
 287 }
 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 
 296 /*
 297  * Common EUC code.
 298  */
 299 
 300 static size_t
 301 _EUC_mbrtowc_impl(wchar_t *_RESTRICT_KYWD pwc, const char *_RESTRICT_KYWD s,
 302         size_t n, mbstate_t *_RESTRICT_KYWD ps,
 303         uint8_t cs2, uint8_t cs2width, uint8_t cs3, uint8_t cs3width)
 304 {
 305         _EucState *es;
 306         int i, want;
 307         wchar_t wc;
 308         unsigned char ch;
 309 
 310         es = (_EucState *)ps;
 311 
 312         if (es->want < 0 || es->want > MB_CUR_MAX) {
 313                 errno = EINVAL;
 314                 return ((size_t)-1);
 315         }