locale/FreeBSD/ascii.c

   1 /*-
   2  * Copyright (c) 2002-2004 Tim J. Robbins. All rights reserved.
   3  * Copyright (c) 1993
   4  *      The Regents of the University of California.  All rights reserved.
   5  *
   6  * This code is derived from software contributed to Berkeley by
   7  * Paul Borman at Krystal Technologies.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #include <sys/cdefs.h>
  35 __FBSDID("$FreeBSD: src/lib/libc/locale/ascii.c,v 1.1 2008/01/21 23:48:12 ache Exp $");
  36
  37 #include <errno.h>
  38 #include <limits.h>
  39 #include <runetype.h>
  40 #include <stddef.h>
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include <wchar.h>
  45 #include "mblocal.h"
  46
  47 static size_t   _ascii_mbrtowc(wchar_t * __restrict, const char * __restrict,
  48                     size_t, mbstate_t * __restrict, locale_t);
  49 static int      _ascii_mbsinit(const mbstate_t *, locale_t);
  50 static size_t   _ascii_mbsnrtowcs(wchar_t * __restrict dst,
  51                     const char ** __restrict src, size_t nms, size_t len,
  52                     mbstate_t * __restrict ps __unused, locale_t);
  53 static size_t   _ascii_wcrtomb(char * __restrict, wchar_t,
  54                     mbstate_t * __restrict, locale_t);
  55 static size_t   _ascii_wcsnrtombs(char * __restrict, const wchar_t ** __restrict,
  56                     size_t, size_t, mbstate_t * __restrict, locale_t);
  57
  58 int
  59 _ascii_init(struct __xlocale_st_runelocale *xrl)
  60 {
  61
  62         xrl->__mbrtowc = _ascii_mbrtowc;
  63         xrl->__mbsinit = _ascii_mbsinit;
  64         xrl->__mbsnrtowcs = _ascii_mbsnrtowcs;
  65         xrl->__wcrtomb = _ascii_wcrtomb;
  66         xrl->__wcsnrtombs = _ascii_wcsnrtombs;
  67         xrl->__mb_cur_max = 1;
  68         xrl->__mb_sb_limit = 128;
  69         return(0);
  70 }
  71
  72 static int
  73 _ascii_mbsinit(const mbstate_t *ps __unused, locale_t loc __unused)
  74 {
  75
  76         /*
  77          * Encoding is not state dependent - we are always in the
  78          * initial state.
  79          */
  80         return (1);
  81 }
  82
  83 static size_t
  84 _ascii_mbrtowc(wchar_t * __restrict pwc, const char * __restrict s, size_t n,
  85     mbstate_t * __restrict ps __unused, locale_t loc __unused)
  86 {
  87
  88         if (s == NULL)
  89                 /* Reset to initial shift state (no-op) */
  90                 return (0);
  91         if (n == 0)
  92                 /* Incomplete multibyte sequence */
  93                 return ((size_t)-2);
  94         if (*s & 0x80) {
  95                 errno = EILSEQ;
  96                 return ((size_t)-1);
  97         }
  98         if (pwc != NULL)
  99                 *pwc = (unsigned char)*s;
 100         return (*s == '\0' ? 0 : 1);
 101 }
 102
 103 static size_t
 104 _ascii_wcrtomb(char * __restrict s, wchar_t wc,
 105     mbstate_t * __restrict ps __unused, locale_t loc __unused)
 106 {
 107
 108         if (s == NULL)
 109                 /* Reset to initial shift state (no-op) */
 110                 return (1);
 111         if (wc < 0 || wc > 127) {
 112                 errno = EILSEQ;
 113                 return ((size_t)-1);
 114         }
 115         *s = (unsigned char)wc;
 116         return (1);
 117 }
 118
 119 static size_t
 120 _ascii_mbsnrtowcs(wchar_t * __restrict dst, const char ** __restrict src,
 121     size_t nms, size_t len, mbstate_t * __restrict ps __unused, locale_t loc __unused)
 122 {
 123         const char *s;
 124         size_t nchr;
 125
 126         if (dst == NULL) {
 127                 for (s = *src; nms > 0 && *s != '\0'; s++, nms--) {
 128                         if (*s & 0x80) {
 129                                 errno = EILSEQ;
 130                                 return ((size_t)-1);
 131                         }
 132                 }
 133                 return (s - *src);
 134         }
 135
 136         s = *src;
 137         nchr = 0;
 138         while (len-- > 0 && nms-- > 0) {
 139                 if (*s & 0x80) {
 140                         errno = EILSEQ;
 141                         return ((size_t)-1);
 142                 }
 143                 if ((*dst++ = (unsigned char)*s++) == L'\0') {
 144                         *src = NULL;
 145                         return (nchr);
 146                 }
 147                 nchr++;
 148         }
 149         *src = s;
 150         return (nchr);
 151 }
 152
 153 static size_t
 154 _ascii_wcsnrtombs(char * __restrict dst, const wchar_t ** __restrict src,
 155     size_t nwc, size_t len, mbstate_t * __restrict ps __unused, locale_t loc __unused)
 156 {
 157         const wchar_t *s;
 158         size_t nchr;
 159
 160         if (dst == NULL) {
 161                 for (s = *src; nwc > 0 && *s != L'\0'; s++, nwc--) {
 162                         if (*s < 0 || *s > 127) {
 163                                 errno = EILSEQ;
 164                                 return ((size_t)-1);
 165                         }
 166                 }
 167                 return (s - *src);
 168         }
 169
 170         s = *src;
 171         nchr = 0;
 172         while (len-- > 0 && nwc-- > 0) {
 173                 if (*s < 0 || *s > 127) {
 174                         errno = EILSEQ;
 175                         return ((size_t)-1);
 176                 }
 177                 if ((*dst++ = *s++) == '\0') {
 178                         *src = NULL;
 179                         return (nchr);
 180                 }
 181                 nchr++;
 182         }
 183         *src = s;
 184         return (nchr);
 185 }
 186