base/string.c

   1 /*
   2  * Copyright (c) 2010 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Portions Copyright (c) 2010 Apple Inc. All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  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  *
  19  * 3. Neither the name of the Institute 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  *
  23  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  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 INSTITUTE 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 "baselocl.h"
  37 #include <string.h>
  38
  39 static void
  40 string_dealloc(void *ptr)
  41 {
  42     heim_string_t s = ptr;
  43     heim_string_free_f_t *deallocp;
  44     heim_string_free_f_t dealloc;
  45
  46     if (*(const char *)ptr != '\0')
  47         return;
  48
  49     /* Possible string ref */
  50     deallocp = _heim_get_isaextra(s, 0);
  51     dealloc = *deallocp;
  52     if (dealloc != NULL) {
  53         char **strp = _heim_get_isaextra(s, 1);
  54         dealloc(*strp);
  55     }
  56 }
  57
  58 static int
  59 string_cmp(void *a, void *b)
  60 {
  61     if (*(char *)a == '\0') {
  62         char **strp = _heim_get_isaextra(a, 1);
  63
  64         if (*strp != NULL)
  65             a = *strp; /* a is a string ref */
  66     }
  67     if (*(char *)b == '\0') {
  68         char **strp = _heim_get_isaextra(b, 1);
  69
  70         if (*strp != NULL)
  71             b = *strp; /* b is a string ref */
  72     }
  73     return strcmp(a, b);
  74 }
  75
  76 static unsigned long
  77 string_hash(void *ptr)
  78 {
  79     const char *s = ptr;
  80     unsigned long n;
  81
  82     for (n = 0; *s; ++s)
  83         n += *s;
  84     return n;
  85 }
  86
  87 struct heim_type_data _heim_string_object = {
  88     HEIM_TID_STRING,
  89     "string-object",
  90     NULL,
  91     string_dealloc,
  92     NULL,
  93     string_cmp,
  94     string_hash
  95 };
  96
  97 /**
  98  * Create a string object
  99  *
 100  * @param string the string to create, must be an utf8 string
 101  *
 102  * @return string object
 103  */
 104
 105 heim_string_t
 106 heim_string_create(const char *string)
 107 {
 108     return heim_string_create_with_bytes(string, strlen(string));
 109 }
 110
 111 /**
 112  * Create a string object without copying the source.
 113  *
 114  * @param string the string to referenced, must be UTF-8
 115  * @param dealloc the function to use to release the referece to the string
 116  *
 117  * @return string object
 118  */
 119
 120 heim_string_t
 121 heim_string_ref_create(const char *string, heim_string_free_f_t dealloc)
 122 {
 123     heim_string_t s;
 124     heim_string_free_f_t *deallocp;
 125
 126     s = _heim_alloc_object(&_heim_string_object, 1);
 127     if (s) {
 128         const char **strp;
 129
 130         ((char *)s)[0] = '\0';
 131         deallocp = _heim_get_isaextra(s, 0);
 132         *deallocp = dealloc;
 133         strp = _heim_get_isaextra(s, 1);
 134         *strp = string;
 135     }
 136     return s;
 137 }
 138
 139 /**
 140  * Create a string object
 141  *
 142  * @param string the string to create, must be an utf8 string
 143  * @param len the length of the string
 144  *
 145  * @return string object
 146  */
 147
 148 heim_string_t
 149 heim_string_create_with_bytes(const void *data, size_t len)
 150 {
 151     heim_string_t s;
 152
 153     s = _heim_alloc_object(&_heim_string_object, len + 1);
 154     if (s) {
 155         memcpy(s, data, len);
 156         ((char *)s)[len] = '\0';
 157     }
 158     return s;
 159 }
 160
 161 /**
 162  * Return the type ID of string objects
 163  *
 164  * @return type id of string objects
 165  */
 166
 167 heim_tid_t
 168 heim_string_get_type_id(void)
 169 {
 170     return HEIM_TID_STRING;
 171 }
 172
 173 /**
 174  * Get the string value of the content.
 175  *
 176  * @param string the string object to get the value from
 177  *
 178  * @return a utf8 string
 179  */
 180
 181 const char *
 182 heim_string_get_utf8(heim_string_t string)
 183 {
 184     if (*(const char *)string == '\0') {
 185         const char **strp;
 186
 187         /* String ref */
 188         strp = _heim_get_isaextra(string, 1);
 189         if (*strp != NULL)
 190             return *strp;
 191     }
 192     return (const char *)string;
 193 }
 194
 195 /*
 196  *
 197  */
 198
 199 static void
 200 init_string(void *ptr)
 201 {
 202     heim_dict_t *dict = ptr;
 203     *dict = heim_dict_create(101);
 204     heim_assert(*dict != NULL, "__heim_string_constant");
 205 }
 206
 207 heim_string_t
 208 __heim_string_constant(const char *_str)
 209 {
 210     static HEIMDAL_MUTEX mutex = HEIMDAL_MUTEX_INITIALIZER;
 211     static heim_base_once_t once;
 212     static heim_dict_t dict = NULL;
 213     heim_string_t s, s2;
 214
 215     heim_base_once_f(&once, &dict, init_string);
 216     s = heim_string_create(_str);
 217
 218     HEIMDAL_MUTEX_lock(&mutex);
 219     s2 = heim_dict_get_value(dict, s);
 220     if (s2) {
 221         heim_release(s);
 222         s = s2;
 223     } else {
 224         _heim_make_permanent(s);
 225         heim_dict_set_value(dict, s, s);
 226     }
 227     HEIMDAL_MUTEX_unlock(&mutex);
 228
 229     return s;
 230 }