string/strxfrm-fbsd.c

   1 /*-
   2  * Copyright (c) 1995 Alex Tatmanjants <alex@elvisti.kiev.ua>
   3  *              at Electronni Visti IA, Kiev, Ukraine.
   4  *                      All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include <sys/cdefs.h>
  29 __FBSDID("$FreeBSD: src/lib/libc/string/strxfrm.c,v 1.15 2002/09/06 11:24:06 tjr Exp $");
  30
  31 #include "xlocale_private.h"
  32
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <wchar.h>
  36 #include <errno.h>
  37 #include "collate.h"
  38
  39 /*
  40  * In the non-POSIX case, we transform each character into a string of
  41  * characters representing the character's priority.  Since char is usually
  42  * signed, we are limited by 7 bits per byte.  To avoid zero, we need to add
  43  * XFRM_OFFSET, so we can't use a full 7 bits.  For simplicity, we choose 6
  44  * bits per byte.  We choose 4 bytes per character as a good compromise
  45  * between maximum coverage and minimum size.  This gives 24 bits, or 16M
  46  * priorities.  So we choose COLLATE_MAX_PRIORITY to be (2^24 - 1).  This
  47  * this can be increased if more is needed.
  48  */
  49
  50 #define XFRM_BYTES      4
  51 #define XFRM_OFFSET     ('0')   /* make all printable characters */
  52 #define XFRM_SHIFT      6
  53 #define XFRM_MASK       ((1 << XFRM_SHIFT) - 1)
  54
  55 static void
  56 xfrm(unsigned char *p, int pri)
  57 {
  58
  59         p[3] = (pri & XFRM_MASK) + XFRM_OFFSET;
  60         pri >>= XFRM_SHIFT;
  61         p[2] = (pri & XFRM_MASK) + XFRM_OFFSET;
  62         pri >>= XFRM_SHIFT;
  63         p[1] = (pri & XFRM_MASK) + XFRM_OFFSET;
  64         pri >>= XFRM_SHIFT;
  65         p[0] = (pri & XFRM_MASK) + XFRM_OFFSET;
  66 }
  67
  68 size_t
  69 strxfrm_l(char * __restrict dest, const char * __restrict src, size_t len,
  70     locale_t loc)
  71 {
  72         size_t slen;
  73         wchar_t *wcs, *xf[2];
  74         int sverrno;
  75
  76         if (!*src && dest) {
  77                 if (len > 0)
  78                         *dest = '\0';
  79                 return 0;
  80         }
  81
  82         NORMALIZE_LOCALE(loc);
  83         if (loc->__collate_load_error || (wcs = __collate_mbstowcs(src, loc)) == NULL) {
  84                 slen = strlen(src);
  85                 if (len > 0) {
  86                         if (slen < len)
  87                                 strcpy(dest, src);
  88                         else {
  89                                 strncpy(dest, src, len - 1);
  90                                 dest[len - 1] = '\0';
  91                         }
  92                 }
  93                 return slen;
  94         }
  95
  96         __collate_xfrm(wcs, xf, loc);
  97
  98         slen = wcslen(xf[0]) * XFRM_BYTES;
  99         if (xf[1])
 100                 slen += (wcslen(xf[1]) + 1) * XFRM_BYTES;
 101         if (len > 0) {
 102                 wchar_t *w = xf[0];
 103                 int b = 0;
 104                 unsigned char buf[XFRM_BYTES];
 105                 unsigned char *bp;
 106                 while (len > 1) {
 107                         if (!b) {
 108                                 if (!*w)
 109                                         break;
 110                                 xfrm(bp = buf, *w++);
 111                                 b = XFRM_BYTES;
 112                         }
 113                         *dest++ = *(char *)bp++;
 114                         b--;
 115                         len--;
 116                 }
 117                 if ((w = xf[1]) != NULL) {
 118                         xfrm(bp = buf, 0);
 119                         b = XFRM_BYTES;
 120                         while (len > 1) {
 121                                 if (!b)
 122                                         break;
 123                                 *dest++ = *(char *)bp++;
 124                                 b--;
 125                                 len--;
 126                         }
 127                         b = 0;
 128                         while (len > 1) {
 129                                 if (!b) {
 130                                         if (!*w)
 131                                                 break;
 132                                         xfrm(bp = buf, *w++);
 133                                         b = XFRM_BYTES;
 134                                 }
 135                                 *dest++ = *(char *)bp++;
 136                                 b--;
 137                                 len--;
 138                         }
 139                 }
 140                 *dest = 0;
 141         }
 142         sverrno = errno;
 143         free(wcs);
 144         free(xf[0]);
 145         free(xf[1]);
 146         errno = sverrno;
 147
 148         return slen;
 149 }
 150
 151 size_t
 152 strxfrm(char * __restrict dest, const char * __restrict src, size_t len)
 153 {
 154         return strxfrm_l(dest, src, len, __current_locale());
 155 }