lib/libc/citrus/citrus_none.c

   1 /*      $NetBSD: citrus_none.c,v 1.18 2008/06/14 16:01:07 tnozaki Exp $ */
   2
   3 /*-
   4  * Copyright (c)2002 Citrus Project,
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/cdefs.h>
  30 #if defined(LIBC_SCCS) && !defined(lint)
  31 __RCSID("$NetBSD: citrus_none.c,v 1.18 2008/06/14 16:01:07 tnozaki Exp $");
  32 #endif /* LIBC_SCCS and not lint */
  33
  34 #include <assert.h>
  35 #include <errno.h>
  36 #include <string.h>
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <stddef.h>
  40 #include <wchar.h>
  41 #include <sys/types.h>
  42
  43 #include "citrus_namespace.h"
  44 #include "citrus_types.h"
  45 #include "citrus_module.h"
  46 #include "citrus_ctype.h"
  47 #include "citrus_none.h"
  48 #include "citrus_stdenc.h"
  49
  50 /* ---------------------------------------------------------------------- */
  51
  52 _CITRUS_CTYPE_DECLS(NONE);
  53 _CITRUS_CTYPE_DEF_OPS(NONE);
  54
  55
  56 /* ---------------------------------------------------------------------- */
  57
  58 static int
  59 /*ARGSUSED*/
  60 _citrus_NONE_ctype_init(void ** __restrict cl, void * __restrict var,
  61                         size_t lenvar, size_t lenps)
  62 {
  63         *cl = NULL;
  64         return (0);
  65 }
  66
  67 static void
  68 /*ARGSUSED*/
  69 _citrus_NONE_ctype_uninit(void *cl)
  70 {
  71 }
  72
  73 static unsigned
  74 /*ARGSUSED*/
  75 _citrus_NONE_ctype_get_mb_cur_max(void *cl)
  76 {
  77         return (1);
  78 }
  79
  80 static int
  81 /*ARGSUSED*/
  82 _citrus_NONE_ctype_mblen(void * __restrict cl, const char * __restrict s,
  83                          size_t n, int * __restrict nresult)
  84 {
  85         if (!s) {
  86                 *nresult = 0; /* state independent */
  87                 return (0);
  88         }
  89         if (n==0) {
  90                 *nresult = -1;
  91                 return (EILSEQ);
  92         }
  93         *nresult = (*s == 0) ? 0 : 1;
  94         return (0);
  95 }
  96
  97 static int
  98 /*ARGSUSED*/
  99 _citrus_NONE_ctype_mbrlen(void * __restrict cl, const char * __restrict s,
 100                           size_t n, void * __restrict pspriv,
 101                           size_t * __restrict nresult)
 102 {
 103         if (!s) {
 104                 *nresult = 0;
 105                 return (0);
 106         }
 107         if (n==0) {
 108                 *nresult = (size_t)-2;
 109                 return (0);
 110         }
 111         *nresult = (*s == 0) ? 0 : 1;
 112         return (0);
 113 }
 114
 115 static int
 116 /*ARGSUSED*/
 117 _citrus_NONE_ctype_mbrtowc(void * __restrict cl, wchar_t * __restrict pwc,
 118                            const char * __restrict s, size_t n,
 119                            void * __restrict pspriv,
 120                            size_t * __restrict nresult)
 121 {
 122         if (s == NULL) {
 123                 *nresult = 0;
 124                 return (0);
 125         }
 126         if (n == 0) {
 127                 *nresult = (size_t)-2;
 128                 return (0);
 129         }
 130
 131         if (pwc != NULL)
 132                 *pwc = (wchar_t)(unsigned char) *s;
 133
 134         *nresult = *s == '\0' ? 0 : 1;
 135         return (0);
 136 }
 137
 138 static int
 139 /*ARGSUSED*/
 140 _citrus_NONE_ctype_mbsinit(void * __restrict cl,
 141                            const void * __restrict pspriv,
 142                            int * __restrict nresult)
 143 {
 144         *nresult = 1;  /* always initial state */
 145         return (0);
 146 }
 147
 148 static int
 149 /*ARGSUSED*/
 150 _citrus_NONE_ctype_mbsrtowcs(void * __restrict cl, wchar_t * __restrict pwcs,
 151                              const char ** __restrict s, size_t n,
 152                              void * __restrict pspriv,
 153                              size_t * __restrict nresult)
 154 {
 155         int cnt;
 156         const char *s0;
 157
 158         /* if pwcs is NULL, ignore n */
 159         if (pwcs == NULL)
 160                 n = 1; /* arbitrary >0 value */
 161
 162         cnt = 0;
 163         s0 = *s; /* to keep *s unchanged for now, use copy instead. */
 164         while (n > 0) {
 165                 if (pwcs != NULL) {
 166                         *pwcs = (wchar_t)(unsigned char)*s0;
 167                 }
 168                 if (*s0 == '\0') {
 169                         s0 = NULL;
 170                         break;
 171                 }
 172                 s0++;
 173                 if (pwcs != NULL) {
 174                         pwcs++;
 175                         n--;
 176                 }
 177                 cnt++;
 178         }
 179         if (pwcs)
 180                 *s = s0;
 181
 182         *nresult = (size_t)cnt;
 183
 184         return (0);
 185 }
 186
 187 static int
 188 _citrus_NONE_ctype_mbstowcs(void * __restrict cl, wchar_t * __restrict wcs,
 189                             const char * __restrict s, size_t n,
 190                             size_t * __restrict nresult)
 191 {
 192         const char *rs = s;
 193
 194         return (_citrus_NONE_ctype_mbsrtowcs(cl, wcs, &rs, n, NULL, nresult));
 195 }
 196
 197 static int
 198 /*ARGSUSED*/
 199 _citrus_NONE_ctype_mbtowc(void * __restrict cl, wchar_t * __restrict pwc,
 200                           const char * __restrict s, size_t n,
 201                           int * __restrict nresult)
 202 {
 203
 204         if (s == NULL) {
 205                 *nresult = 0; /* state independent */
 206                 return (0);
 207         }
 208         if (n == 0) {
 209                 return (EILSEQ);
 210         }
 211         if (pwc == NULL) {
 212                 if (*s == '\0') {
 213                         *nresult = 0;
 214                 } else {
 215                         *nresult = 1;
 216                 }
 217                 return (0);
 218         }
 219
 220         *pwc = (wchar_t)(unsigned char)*s;
 221         *nresult = *s == '\0' ? 0 : 1;
 222
 223         return (0);
 224 }
 225
 226 static int
 227 /*ARGSUSED*/
 228 _citrus_NONE_ctype_wcrtomb(void * __restrict cl, char * __restrict s,
 229                            wchar_t wc, void * __restrict pspriv,
 230                            size_t * __restrict nresult)
 231 {
 232         if ((wc&~0xFFU) != 0) {
 233                 *nresult = (size_t)-1;
 234                 return (EILSEQ);
 235         }
 236
 237         *nresult = 1;
 238         if (s!=NULL)
 239                 *s = (char)wc;
 240
 241         return (0);
 242 }
 243
 244 static int
 245 /*ARGSUSED*/
 246 _citrus_NONE_ctype_wcsrtombs(void * __restrict cl, char * __restrict s,
 247                              const wchar_t ** __restrict pwcs, size_t n,
 248                              void * __restrict pspriv,
 249                              size_t * __restrict nresult)
 250 {
 251         size_t count;
 252         const wchar_t *pwcs0;
 253
 254         pwcs0 = *pwcs;
 255         count = 0;
 256
 257         if (s == NULL)
 258                 n = 1;
 259
 260         while (n > 0) {
 261                 if ((*pwcs0 & ~0xFFU) != 0) {
 262                         *nresult = (size_t)-1;
 263                         return (EILSEQ);
 264                 }
 265                 if (s != NULL) {
 266                         *s++ = (char)*pwcs0;
 267                         n--;
 268                 }
 269                 if (*pwcs0 == L'\0') {
 270                         pwcs0 = NULL;
 271                         break;
 272                 }
 273                 count++;
 274                 pwcs0++;
 275         }
 276         if (s != NULL)
 277                 *pwcs = pwcs0;
 278
 279         *nresult = count;
 280
 281         return (0);
 282 }
 283
 284 static int
 285 _citrus_NONE_ctype_wcstombs(void * __restrict cl, char * __restrict s,
 286                             const wchar_t * __restrict pwcs, size_t n,
 287                             size_t * __restrict nresult)
 288 {
 289         const wchar_t *rpwcs = pwcs;
 290
 291         return (_citrus_NONE_ctype_wcsrtombs(cl, s, &rpwcs, n, NULL, nresult));
 292 }
 293
 294 static int
 295 _citrus_NONE_ctype_wctomb(void * __restrict cl, char * __restrict s,
 296                           wchar_t wc, int * __restrict nresult)
 297 {
 298         int ret;
 299         size_t nr;
 300
 301         if (s == 0) {
 302                 /*
 303                  * initialize state here.
 304                  * (nothing to do for us.)
 305                  */
 306                 *nresult = 0; /* we're state independent */
 307                 return (0);
 308         }
 309
 310         ret = _citrus_NONE_ctype_wcrtomb(cl, s, wc, NULL, &nr);
 311         *nresult = (int)nr;
 312
 313         return (ret);
 314 }
 315
 316 static int
 317 /*ARGSUSED*/
 318 _citrus_NONE_ctype_btowc(_citrus_ctype_rec_t * __restrict cc,
 319                          int c, wint_t * __restrict wcresult)
 320 {
 321         if (c == EOF || c & ~0xFF)
 322                 *wcresult = WEOF;
 323         else
 324                 *wcresult = (wint_t)c;
 325         return (0);
 326 }
 327
 328 static int
 329 /*ARGSUSED*/
 330 _citrus_NONE_ctype_wctob(_citrus_ctype_rec_t * __restrict cc,
 331                          wint_t wc, int * __restrict cresult)
 332 {
 333         if (wc == WEOF || wc & ~0xFF)
 334                 *cresult = EOF;
 335         else
 336                 *cresult = (int)wc;
 337         return (0);
 338 }
 339
 340 /* ---------------------------------------------------------------------- */
 341
 342 _CITRUS_STDENC_DECLS(NONE);
 343 _CITRUS_STDENC_DEF_OPS(NONE);
 344 struct _citrus_stdenc_traits _citrus_NONE_stdenc_traits = {
 345         0,      /* et_state_size */
 346         1,      /* mb_cur_max */
 347 };
 348
 349 static int
 350 /*ARGSUSED*/
 351 _citrus_NONE_stdenc_init(struct _citrus_stdenc * __restrict ce,
 352                          const void *var, size_t lenvar,
 353                          struct _citrus_stdenc_traits * __restrict et)
 354 {
 355
 356         et->et_state_size = 0;
 357         et->et_mb_cur_max = 1;
 358
 359         ce->ce_closure = NULL;
 360
 361         return (0);
 362 }
 363
 364 static void
 365 /*ARGSUSED*/
 366 _citrus_NONE_stdenc_uninit(struct _citrus_stdenc *ce)
 367 {
 368 }
 369
 370 static int
 371 /*ARGSUSED*/
 372 _citrus_NONE_stdenc_init_state(struct _citrus_stdenc * __restrict ce,
 373                                void * __restrict ps)
 374 {
 375         return (0);
 376 }
 377
 378 static int
 379 /*ARGSUSED*/
 380 _citrus_NONE_stdenc_mbtocs(struct _citrus_stdenc * __restrict ce,
 381                            _csid_t *csid, _index_t *idx,
 382                            const char **s, size_t n,
 383                            void *ps, size_t *nresult)
 384 {
 385
 386         _DIAGASSERT(csid != NULL && idx != NULL);
 387
 388         if (n<1) {
 389                 *nresult = (size_t)-2;
 390                 return (0);
 391         }
 392
 393         *csid = 0;
 394         *idx = (_index_t)(unsigned char)*(*s)++;
 395         *nresult = *idx == 0 ? 0 : 1;
 396
 397         return (0);
 398 }
 399
 400 static int
 401 /*ARGSUSED*/
 402 _citrus_NONE_stdenc_cstomb(struct _citrus_stdenc * __restrict ce,
 403                            char *s, size_t n,
 404                            _csid_t csid, _index_t idx,
 405                            void *ps, size_t *nresult)
 406 {
 407
 408         if (csid == _CITRUS_CSID_INVALID) {
 409                 *nresult = 0;
 410                 return (0);
 411         }
 412         if (n<1) {
 413                 *nresult = (size_t)-1;
 414                 return (E2BIG);
 415         }
 416         if (csid != 0 || (idx&0xFF) != idx)
 417                 return (EILSEQ);
 418
 419         *s = (char)idx;
 420         *nresult = 1;
 421
 422         return (0);
 423 }
 424
 425 static int
 426 /*ARGSUSED*/
 427 _citrus_NONE_stdenc_mbtowc(struct _citrus_stdenc * __restrict ce,
 428                            _wc_t * __restrict pwc,
 429                            const char ** __restrict s, size_t n,
 430                            void * __restrict pspriv,
 431                            size_t * __restrict nresult)
 432 {
 433         if (s == NULL) {
 434                 *nresult = 0;
 435                 return (0);
 436         }
 437         if (n == 0) {
 438                 *nresult = (size_t)-2;
 439                 return (0);
 440         }
 441
 442         if (pwc != NULL)
 443                 *pwc = (_wc_t)(unsigned char) **s;
 444
 445         *nresult = *s == '\0' ? 0 : 1;
 446         return (0);
 447 }
 448
 449 static int
 450 /*ARGSUSED*/
 451 _citrus_NONE_stdenc_wctomb(struct _citrus_stdenc * __restrict ce,
 452                            char * __restrict s, size_t n,
 453                            _wc_t wc, void * __restrict pspriv,
 454                            size_t * __restrict nresult)
 455 {
 456         if ((wc&~0xFFU) != 0) {
 457                 *nresult = (size_t)-1;
 458                 return (EILSEQ);
 459         }
 460         if (n==0) {
 461                 *nresult = (size_t)-1;
 462                 return (E2BIG);
 463         }
 464
 465         *nresult = 1;
 466         if (s!=NULL && n>0)
 467                 *s = (char)wc;
 468
 469         return (0);
 470 }
 471
 472 static int
 473 /*ARGSUSED*/
 474 _citrus_NONE_stdenc_put_state_reset(struct _citrus_stdenc * __restrict ce,
 475                                     char * __restrict s, size_t n,
 476                                     void * __restrict pspriv,
 477                                     size_t * __restrict nresult)
 478 {
 479
 480         *nresult = 0;
 481
 482         return (0);
 483 }
 484
 485 static int
 486 /*ARGSUSED*/
 487 _citrus_NONE_stdenc_get_state_desc(struct _stdenc * __restrict ce,
 488                                    void * __restrict ps,
 489                                    int id,
 490                                    struct _stdenc_state_desc * __restrict d)
 491 {
 492         int ret = 0;
 493
 494         switch (id) {
 495         case _STDENC_SDID_GENERIC:
 496                 d->u.generic.state = _STDENC_SDGEN_INITIAL;
 497                 break;
 498         default:
 499                 ret = EOPNOTSUPP;
 500         }
 501
 502         return ret;
 503 }