engine/strings.h

   1 /*
   2   strings.h - MaLa string handling
   3
   4   Copyright (C) 2004, 2005, Christian Thaeter <chth@gmx.net>
   5
   6   This program is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU General Public License version 2 as
   8   published by the Free Software Foundation.
   9
  10   This program is distributed in the hope that it will be useful,
  11   but WITHOUT ANY WARRANTY; without even the implied warranty of
  12   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13   GNU General Public License for more details.
  14
  15   You should have received a copy of the GNU General Public License
  16   along with this program; if not, contact me.
  17
  18 */
  19 \f
  20 #ifndef MALA_STRINGS_H
  21 #define MALA_STRINGS_H
  22
  23 #include <string.h>
  24 #include <stdint.h>
  25 #include <search.h>
  26 #include <stdlib.h>
  27 #include "mala_types.h"
  28 #include "strings.h"
  29 #include "stringbucket.h"
  30
  31 \f
  32 struct mala_string_struct
  33 {
  34   const char * str;
  35   size_t len;                   // MAX_SIZE means 'not yet counted'
  36   unsigned long refcnt;         // lowest bits: 0x1 descriptor is not on heap,
  37                                 //              0x2 data is not on heap
  38                                 // refcount is increased/decreased by 4 for each reference,
  39                                 // because of the used lower bits
  40   MalaStringBucket bucket;
  41   void * user;
  42 };
  43
  44 // static strings are initialized by "literals"
  45 #define MALA_STRING_STATIC(literal) &(mala_string){literal,sizeof(literal)-1,0x3,NULL,NULL}
  46 // automatic strings can be initialized by any const char*
  47 #define MALA_STRING_AUTO(cstr) {cstr,SIZE_MAX,0x3,NULL,NULL}
  48
  49 \f
  50 /*
  51  * Declarations
  52  */
  53 MalaString
  54 mala_string_new_cstr_attach (char* cstr, MalaStringBucket bucket);
  55
  56 MalaString
  57 mala_string_new (const char* cstr, MalaStringBucket bucket);
  58
  59 MalaString
  60 mala_string_new_n (const char* cstr, const size_t n, MalaStringBucket bucket);
  61
  62 MalaString
  63 mala_string_new_cat2 (const char* cstr1, const char* cstr2, MalaStringBucket bucket);
  64
  65 MalaString
  66 mala_string_find (const char* cstr, MalaStringBucket bucket);
  67
  68 MalaString
  69 mala_string_copy_n (MalaString src, const size_t n);
  70
  71 MalaString
  72 mala_string_new_prefix (const char* prefix, MalaString str);
  73
  74 //MalaString
  75 //mala_string_cat_n (MalaString_ref dest, MalaString src, size_t n);
  76 //MalaString
  77 //mala_string_cat_nn (MalaString_ref dest, size_t n, MalaString src, size_t n);
  78
  79 MalaString
  80 mala_string_new_print (MalaStringBucket bucket, const char* fmt,...);
  81
  82 int
  83 mala_string_scan (const_MalaString str,const char* fmt,...);
  84
  85 void
  86 mala_string_free (MalaString s);
  87
  88 void
  89 mala_string_free_forced (MalaString s);
  90
  91 MalaString
  92 mala_string_factory (MalaString_ref dest, const char* src, MalaStringBucket bucket);
  93
  94 void
  95 mala_string_data_free (MalaString s);
  96
  97 size_t
  98 mala_string_char_find (MalaString self, const char c);
  99
 100 MalaString
 101 mala_string_new_substr (MalaString self, size_t start, size_t end);
 102
 103
 104 /*statics*/
 105 static inline void*
 106 mala_string_user_get (const_MalaString s);
 107
 108 static inline void*
 109 mala_string_user_set (MalaString s, void* data);
 110
 111 static inline MalaStringBucket
 112 mala_string_bucket_get (const_MalaString s);
 113
 114 static inline const char*
 115 mala_string_cstr (const_MalaString s);
 116
 117 static inline size_t
 118 mala_string_length (MalaString s);
 119
 120 static inline size_t
 121 mala_string_references (const_MalaString s);
 122
 123 static inline int
 124 mala_string_same (const_MalaString a, const_MalaString b);
 125
 126 static inline int
 127 mala_string_check_prefix (const_MalaString self, const char* prefix);
 128
 129 static inline int
 130 mala_string_check_prefix_nocase (const_MalaString self, const char* prefix);
 131
 132 static inline int
 133 mala_string_compare (const_MalaString a, const_MalaString b);
 134
 135 static inline int
 136 mala_string_compare_nocase (const_MalaString a, const_MalaString b);
 137
 138 //static inline int mala_string_compare_rev (const_MalaString a, const_MalaString b);
 139
 140 static inline int
 141 mala_string_compare_n (const_MalaString a, const_MalaString b, const size_t n);
 142
 143 static inline int
 144 mala_string_compare_n_nocase (const_MalaString a, const_MalaString b, size_t n);
 145
 146 static inline MalaString
 147 mala_string_copy (MalaString src);
 148
 149 static inline int
 150 mala_string_at (MalaString self, unsigned n);
 151
 152 \f
 153 /*
 154  * Inlines
 155  */
 156
 157 static inline void*
 158 mala_string_user_get (const_MalaString s)
 159 {
 160   return (s && s->bucket) ? s->user : NULL;
 161 }
 162
 163
 164 static inline void*
 165 mala_string_user_set (MalaString s, void* data)
 166 {
 167   return s->user = s->bucket ? data : NULL;
 168 }
 169
 170
 171 static inline MalaStringBucket
 172 mala_string_bucket_get (const_MalaString s)
 173 {
 174   return s->bucket;
 175 }
 176
 177
 178 static inline const char*
 179 mala_string_cstr (const_MalaString s)
 180 {
 181   return s->str;
 182 }
 183
 184
 185 static inline size_t
 186 mala_string_length (MalaString s)
 187 {
 188   return s->len != SIZE_MAX ?  s->len : (s->len = strlen (s->str));
 189 }
 190
 191
 192 static inline size_t
 193 mala_string_references (const_MalaString s)
 194 {
 195   return s->refcnt>>2;
 196 }
 197
 198 static inline int
 199 mala_string_same (const_MalaString a, const_MalaString b)
 200 {
 201   return a == b;
 202 }
 203
 204 static inline int
 205 mala_string_check_prefix (const_MalaString self, const char* prefix)
 206 {
 207   return strncmp(self->str, prefix, strlen(prefix)) == 0;
 208 }
 209
 210 static inline int
 211 mala_string_check_prefix_nocase (const_MalaString self, const char* prefix)
 212 {
 213   return strncasecmp(self->str, prefix, strlen(prefix)) == 0;
 214 }
 215
 216
 217 static inline int
 218 mala_string_compare (const_MalaString a, const_MalaString b)
 219 {
 220   return a == b ? 0 : strcmp (mala_string_cstr (a), mala_string_cstr (b));
 221 }
 222
 223
 224 static inline int
 225 mala_string_compare_nocase (const_MalaString a, const_MalaString b)
 226 {
 227   return a == b ? 0 : strcasecmp (mala_string_cstr (a), mala_string_cstr (b));
 228 }
 229
 230 /*
 231 static inline int
 232 mala_string_compare_rev (const_MalaString a, const_MalaString b)
 233 {
 234   return mala_string_compare (b,a);
 235 }
 236 */
 237
 238 static inline int
 239 mala_string_compare_n (const_MalaString a, const_MalaString b, const size_t n)
 240 {
 241   return a == b ? 0 : strncmp (mala_string_cstr (a), mala_string_cstr (b), n);
 242 }
 243
 244
 245 static inline int
 246 mala_string_compare_n_nocase (const_MalaString a, const_MalaString b, const size_t n)
 247 {
 248   return a == b ? 0 : strncasecmp (mala_string_cstr (a), mala_string_cstr (b), n);
 249 }
 250
 251 static inline MalaString
 252 mala_string_copy (MalaString src)
 253 {
 254   src->refcnt += 4;
 255   return src;
 256 }
 257
 258 static inline int
 259 mala_string_at (MalaString self, unsigned n)
 260 {
 261   MALA_ASSERT (mala_string_length (self) > n);
 262   return self->str[n];
 263 }
 264
 265
 266 #endif /* MALA_STRINGS */
 267
 268 /*
 269 // Local Variables:
 270 // mode: C
 271 // c-file-style: "gnu"
 272 // End:
 273 // arch-tag: b43b7350-ecb6-4aa8-94d3-930da822e3ea
 274 // end_of_file
 275 */
 276