Mercurial > hg > dav / file comparison

comparison: ucx/string.c

ucx/string.c

changeset 505
481802342fdf
parent 335
c1bc13faadaa
child 747
efbd59642577
equal deleted inserted replaced
504:bf3695fee719 505:481802342fdf
48 string.ptr = cstring; 48 string.ptr = cstring;
49 string.length = length; 49 string.length = length;
50 return string; 50 return string;
51 } 51 }
52 52
53 size_t sstrnlen(size_t n, sstr_t s, ...) { 53 scstr_t scstr(const char *cstring) {
54 scstr_t string;
55 string.ptr = cstring;
56 string.length = strlen(cstring);
57 return string;
58 }
59
60 scstr_t scstrn(const char *cstring, size_t length) {
61 scstr_t string;
62 string.ptr = cstring;
63 string.length = length;
64 return string;
65 }
66
67
68 size_t scstrnlen(size_t n, ...) {
54 va_list ap; 69 va_list ap;
55 size_t size = s.length; 70 va_start(ap, n);
56 va_start(ap, s); 71
57 72 size_t size = 0;
58 for (size_t i = 1 ; i < n ; i++) { 73
59 sstr_t str = va_arg(ap, sstr_t); 74 for (size_t i = 0 ; i < n ; i++) {
75 scstr_t str = va_arg(ap, scstr_t);
76 if(SIZE_MAX - str.length < size) {
77 size = SIZE_MAX;
78 break;
79 }
60 size += str.length; 80 size += str.length;
61 } 81 }
62 va_end(ap); 82 va_end(ap);
63 83
64 return size; 84 return size;
65 } 85 }
66 86
67 static sstr_t sstrvcat_a( 87 static sstr_t sstrvcat_a(
68 UcxAllocator *a, 88 UcxAllocator *a,
69 size_t count, 89 size_t count,
70 sstr_t s1, 90 scstr_t s1,
71 sstr_t s2,
72 va_list ap) { 91 va_list ap) {
73 sstr_t str; 92 sstr_t str;
74 str.ptr = NULL; 93 str.ptr = NULL;
75 str.length = 0; 94 str.length = 0;
76 if(count < 2) { 95 if(count < 2) {
77 return str; 96 return str;
78 } 97 }
79 98
80 sstr_t *strings = (sstr_t*) calloc(count, sizeof(sstr_t)); 99 scstr_t s2 = va_arg (ap, scstr_t);
100
101 if(((size_t)-1) - s1.length < s2.length) {
102 return str;
103 }
104
105 scstr_t *strings = (scstr_t*) calloc(count, sizeof(scstr_t));
81 if(!strings) { 106 if(!strings) {
82 return str; 107 return str;
83 } 108 }
84 109
85 // get all args and overall length 110 // get all args and overall length
86 strings[0] = s1; 111 strings[0] = s1;
87 strings[1] = s2; 112 strings[1] = s2;
88 size_t strlen = s1.length + s2.length; 113 size_t slen = s1.length + s2.length;
114 int error = 0;
89 for (size_t i=2;i<count;i++) { 115 for (size_t i=2;i<count;i++) {
90 sstr_t s = va_arg (ap, sstr_t); 116 scstr_t s = va_arg (ap, scstr_t);
91 strings[i] = s; 117 strings[i] = s;
92 strlen += s.length; 118 if(((size_t)-1) - s.length < slen) {
119 error = 1;
120 break;
121 }
122 slen += s.length;
123 }
124 if(error) {
125 free(strings);
126 return str;
93 } 127 }
94 128
95 // create new string 129 // create new string
96 str.ptr = (char*) almalloc(a, strlen + 1); 130 str.ptr = (char*) almalloc(a, slen + 1);
97 str.length = strlen; 131 str.length = slen;
98 if(!str.ptr) { 132 if(!str.ptr) {
99 free(strings); 133 free(strings);
100 str.length = 0; 134 str.length = 0;
101 return str; 135 return str;
102 } 136 }
103 137
104 // concatenate strings 138 // concatenate strings
105 size_t pos = 0; 139 size_t pos = 0;
106 for (size_t i=0;i<count;i++) { 140 for (size_t i=0;i<count;i++) {
107 sstr_t s = strings[i]; 141 scstr_t s = strings[i];
108 memcpy(str.ptr + pos, s.ptr, s.length); 142 memcpy(str.ptr + pos, s.ptr, s.length);
109 pos += s.length; 143 pos += s.length;
110 } 144 }
111 145
112 str.ptr[str.length] = '\0'; 146 str.ptr[str.length] = '\0';
114 free(strings); 148 free(strings);
115 149
116 return str; 150 return str;
117 } 151 }
118 152
119 sstr_t sstrcat(size_t count, sstr_t s1, sstr_t s2, ...) { 153 sstr_t scstrcat(size_t count, scstr_t s1, ...) {
120 va_list ap; 154 va_list ap;
121 va_start(ap, s2); 155 va_start(ap, s1);
122 sstr_t s = sstrvcat_a(ucx_default_allocator(), count, s1, s2, ap); 156 sstr_t s = sstrvcat_a(ucx_default_allocator(), count, s1, ap);
123 va_end(ap); 157 va_end(ap);
124 return s; 158 return s;
125 } 159 }
126 160
127 sstr_t sstrcat_a(UcxAllocator *a, size_t count, sstr_t s1, sstr_t s2, ...) { 161 sstr_t scstrcat_a(UcxAllocator *a, size_t count, scstr_t s1, ...) {
128 va_list ap; 162 va_list ap;
129 va_start(ap, s2); 163 va_start(ap, s1);
130 sstr_t s = sstrvcat_a(a, count, s1, s2, ap); 164 sstr_t s = sstrvcat_a(a, count, s1, ap);
131 va_end(ap); 165 va_end(ap);
132 return s; 166 return s;
133 } 167 }
134 168
169 static int ucx_substring(
170 size_t str_length,
171 size_t start,
172 size_t length,
173 size_t *newlen,
174 size_t *newpos)
175 {
176 *newlen = 0;
177 *newpos = 0;
178
179 if(start > str_length) {
180 return 0;
181 }
182
183 if(length > str_length - start) {
184 length = str_length - start;
185 }
186 *newlen = length;
187 *newpos = start;
188 return 1;
189 }
190
135 sstr_t sstrsubs(sstr_t s, size_t start) { 191 sstr_t sstrsubs(sstr_t s, size_t start) {
136 return sstrsubsl (s, start, s.length-start); 192 return sstrsubsl (s, start, s.length-start);
137 } 193 }
138 194
139 sstr_t sstrsubsl(sstr_t s, size_t start, size_t length) { 195 sstr_t sstrsubsl(sstr_t s, size_t start, size_t length) {
140 sstr_t new_sstr; 196 size_t pos;
141 if (start >= s.length) { 197 sstr_t ret = { NULL, 0 };
142 new_sstr.ptr = NULL; 198 if(ucx_substring(s.length, start, length, &ret.length, &pos)) {
143 new_sstr.length = 0; 199 ret.ptr = s.ptr + pos;
144 } else { 200 }
145 if (length > s.length-start) { 201 return ret;
146 length = s.length-start; 202 }
147 } 203
148 new_sstr.ptr = &s.ptr[start]; 204 scstr_t scstrsubs(scstr_t string, size_t start) {
149 new_sstr.length = length; 205 return scstrsubsl(string, start, string.length-start);
150 } 206 }
151 return new_sstr; 207
208 scstr_t scstrsubsl(scstr_t s, size_t start, size_t length) {
209 size_t pos;
210 scstr_t ret = { NULL, 0 };
211 if(ucx_substring(s.length, start, length, &ret.length, &pos)) {
212 ret.ptr = s.ptr + pos;
213 }
214 return ret;
215 }
216
217
218 static int ucx_strchr(const char *str, size_t length, int chr, size_t *pos) {
219 for(size_t i=0;i<length;i++) {
220 if(str[i] == chr) {
221 *pos = i;
222 return 1;
223 }
224 }
225 return 0;
226 }
227
228 static int ucx_strrchr(const char *str, size_t length, int chr, size_t *pos) {
229 if(length > 0) {
230 for(size_t i=length ; i>0 ; i--) {
231 if(str[i-1] == chr) {
232 *pos = i-1;
233 return 1;
234 }
235 }
236 }
237 return 0;
152 } 238 }
153 239
154 sstr_t sstrchr(sstr_t s, int c) { 240 sstr_t sstrchr(sstr_t s, int c) {
155 for(size_t i=0;i<s.length;i++) { 241 size_t pos = 0;
156 if(s.ptr[i] == c) { 242 if(ucx_strchr(s.ptr, s.length, c, &pos)) {
157 return sstrsubs(s, i); 243 return sstrsubs(s, pos);
158 } 244 }
159 } 245 return sstrn(NULL, 0);
160 sstr_t n;
161 n.ptr = NULL;
162 n.length = 0;
163 return n;
164 } 246 }
165 247
166 sstr_t sstrrchr(sstr_t s, int c) { 248 sstr_t sstrrchr(sstr_t s, int c) {
167 if (s.length > 0) { 249 size_t pos = 0;
168 for(size_t i=s.length;i>0;i--) { 250 if(ucx_strrchr(s.ptr, s.length, c, &pos)) {
169 if(s.ptr[i-1] == c) { 251 return sstrsubs(s, pos);
170 return sstrsubs(s, i-1); 252 }
171 } 253 return sstrn(NULL, 0);
172 } 254 }
173 } 255
174 sstr_t n; 256 scstr_t scstrchr(scstr_t s, int c) {
175 n.ptr = NULL; 257 size_t pos = 0;
176 n.length = 0; 258 if(ucx_strchr(s.ptr, s.length, c, &pos)) {
177 return n; 259 return scstrsubs(s, pos);
260 }
261 return scstrn(NULL, 0);
262 }
263
264 scstr_t scstrrchr(scstr_t s, int c) {
265 size_t pos = 0;
266 if(ucx_strrchr(s.ptr, s.length, c, &pos)) {
267 return scstrsubs(s, pos);
268 }
269 return scstrn(NULL, 0);
178 } 270 }
179 271
180 #define ptable_r(dest, useheap, ptable, index) (dest = useheap ? \ 272 #define ptable_r(dest, useheap, ptable, index) (dest = useheap ? \
181 ((size_t*)ptable)[index] : (size_t) ((uint8_t*)ptable)[index]) 273 ((size_t*)ptable)[index] : (size_t) ((uint8_t*)ptable)[index])
182 274
183 #define ptable_w(useheap, ptable, index, src) do {\ 275 #define ptable_w(useheap, ptable, index, src) do {\
184 if (!useheap) ((uint8_t*)ptable)[index] = (uint8_t) src;\ 276 if (!useheap) ((uint8_t*)ptable)[index] = (uint8_t) src;\
185 else ((size_t*)ptable)[index] = src;\ 277 else ((size_t*)ptable)[index] = src;\
186 } while (0); 278 } while (0);
187 279
188 sstr_t sstrstr(sstr_t string, sstr_t match) { 280
189 if (match.length == 0) { 281 static const char* ucx_strstr(
190 return string; 282 const char *str,
191 } 283 size_t length,
192 284 const char *match,
193 /* prepare default return value in case of no match */ 285 size_t matchlen,
194 sstr_t result = sstrn(NULL, 0); 286 size_t *newlen)
287 {
288 *newlen = length;
289 if (matchlen == 0) {
290 return str;
291 }
292
293 const char *result = NULL;
294 size_t resultlen = 0;
195 295
196 /* 296 /*
197 * IMPORTANT: 297 * IMPORTANT:
198 * our prefix table contains the prefix length PLUS ONE 298 * our prefix table contains the prefix length PLUS ONE
199 * this is our decision, because we want to use the full range of size_t 299 * this is our decision, because we want to use the full range of size_t
204 /* static prefix table */ 304 /* static prefix table */
205 static uint8_t s_prefix_table[256]; 305 static uint8_t s_prefix_table[256];
206 306
207 /* check pattern length and use appropriate prefix table */ 307 /* check pattern length and use appropriate prefix table */
208 /* if the pattern exceeds static prefix table, allocate on the heap */ 308 /* if the pattern exceeds static prefix table, allocate on the heap */
209 register int useheap = match.length > 255; 309 register int useheap = matchlen > 255;
210 register void* ptable = useheap ? 310 register void* ptable = useheap ?
211 calloc(match.length+1, sizeof(size_t)): s_prefix_table; 311 calloc(matchlen+1, sizeof(size_t)): s_prefix_table;
212 312
213 /* keep counter in registers */ 313 /* keep counter in registers */
214 register size_t i, j; 314 register size_t i, j;
215 315
216 /* fill prefix table */ 316 /* fill prefix table */
217 i = 0; j = 0; 317 i = 0; j = 0;
218 ptable_w(useheap, ptable, i, j); 318 ptable_w(useheap, ptable, i, j);
219 while (i < match.length) { 319 while (i < matchlen) {
220 while (j >= 1 && match.ptr[j-1] != match.ptr[i]) { 320 while (j >= 1 && match[j-1] != match[i]) {
221 ptable_r(j, useheap, ptable, j-1); 321 ptable_r(j, useheap, ptable, j-1);
222 } 322 }
223 i++; j++; 323 i++; j++;
224 ptable_w(useheap, ptable, i, j); 324 ptable_w(useheap, ptable, i, j);
225 } 325 }
226 326
227 /* search */ 327 /* search */
228 i = 0; j = 1; 328 i = 0; j = 1;
229 while (i < string.length) { 329 while (i < length) {
230 while (j >= 1 && string.ptr[i] != match.ptr[j-1]) { 330 while (j >= 1 && str[i] != match[j-1]) {
231 ptable_r(j, useheap, ptable, j-1); 331 ptable_r(j, useheap, ptable, j-1);
232 } 332 }
233 i++; j++; 333 i++; j++;
234 if (j-1 == match.length) { 334 if (j-1 == matchlen) {
235 size_t start = i - match.length; 335 size_t start = i - matchlen;
236 result.ptr = string.ptr + start; 336 result = str + start;
237 result.length = string.length - start; 337 resultlen = length - start;
238 break; 338 break;
239 } 339 }
240 } 340 }
241 341
242 /* if prefix table was allocated on the heap, free it */ 342 /* if prefix table was allocated on the heap, free it */
243 if (ptable != s_prefix_table) { 343 if (ptable != s_prefix_table) {
244 free(ptable); 344 free(ptable);
245 } 345 }
246 346
347 *newlen = resultlen;
348 return result;
349 }
350
351 sstr_t scstrsstr(sstr_t string, scstr_t match) {
352 sstr_t result;
353
354 size_t reslen;
355 const char *resstr = ucx_strstr(string.ptr, string.length, match.ptr, match.length, &reslen);
356 if(!resstr) {
357 result.ptr = NULL;
358 result.length = 0;
359 return result;
360 }
361
362 size_t pos = resstr - string.ptr;
363 result.ptr = string.ptr + pos;
364 result.length = reslen;
365
366 return result;
367 }
368
369 scstr_t scstrscstr(scstr_t string, scstr_t match) {
370 scstr_t result;
371
372 size_t reslen;
373 const char *resstr = ucx_strstr(string.ptr, string.length, match.ptr, match.length, &reslen);
374 if(!resstr) {
375 result.ptr = NULL;
376 result.length = 0;
377 return result;
378 }
379
380 size_t pos = resstr - string.ptr;
381 result.ptr = string.ptr + pos;
382 result.length = reslen;
383
247 return result; 384 return result;
248 } 385 }
249 386
250 #undef ptable_r 387 #undef ptable_r
251 #undef ptable_w 388 #undef ptable_w
252 389
253 sstr_t* sstrsplit(sstr_t s, sstr_t d, ssize_t *n) { 390 sstr_t* scstrsplit(scstr_t s, scstr_t d, ssize_t *n) {
254 return sstrsplit_a(ucx_default_allocator(), s, d, n); 391 return scstrsplit_a(ucx_default_allocator(), s, d, n);
255 } 392 }
256 393
257 sstr_t* sstrsplit_a(UcxAllocator *allocator, sstr_t s, sstr_t d, ssize_t *n) { 394 sstr_t* scstrsplit_a(UcxAllocator *allocator, scstr_t s, scstr_t d, ssize_t *n) {
258 if (s.length == 0 || d.length == 0) { 395 if (s.length == 0 || d.length == 0) {
259 *n = -1; 396 *n = -1;
260 return NULL; 397 return NULL;
261 } 398 }
262 399
267 *n = 0; 404 *n = 0;
268 return NULL; 405 return NULL;
269 } else /* no match possible */ { 406 } else /* no match possible */ {
270 *n = 1; 407 *n = 1;
271 sstr_t *result = (sstr_t*) almalloc(allocator, sizeof(sstr_t)); 408 sstr_t *result = (sstr_t*) almalloc(allocator, sizeof(sstr_t));
272 *result = sstrdup_a(allocator, s); 409 if(result) {
410 *result = sstrdup_a(allocator, s);
411 } else {
412 *n = -2;
413 }
273 return result; 414 return result;
274 } 415 }
275 } 416 }
276 417
277 ssize_t nmax = *n; 418 ssize_t nmax = *n;
278 size_t arrlen = 16; 419 size_t arrlen = 16;
279 sstr_t* result = (sstr_t*) almalloc(allocator, arrlen*sizeof(sstr_t)); 420 sstr_t* result = (sstr_t*) alcalloc(allocator, arrlen, sizeof(sstr_t));
280 421
281 if (result) { 422 if (result) {
282 sstr_t curpos = s; 423 scstr_t curpos = s;
283 ssize_t j = 1; 424 ssize_t j = 1;
284 while (1) { 425 while (1) {
285 sstr_t match; 426 scstr_t match;
286 /* optimize for one byte delimiters */ 427 /* optimize for one byte delimiters */
287 if (d.length == 1) { 428 if (d.length == 1) {
288 match = curpos; 429 match = curpos;
289 for (size_t i = 0 ; i < curpos.length ; i++) { 430 for (size_t i = 0 ; i < curpos.length ; i++) {
290 if (curpos.ptr[i] == *(d.ptr)) { 431 if (curpos.ptr[i] == *(d.ptr)) {
292 break; 433 break;
293 } 434 }
294 match.length--; 435 match.length--;
295 } 436 }
296 } else { 437 } else {
297 match = sstrstr(curpos, d); 438 match = scstrscstr(curpos, d);
298 } 439 }
299 if (match.length > 0) { 440 if (match.length > 0) {
300 /* is this our last try? */ 441 /* is this our last try? */
301 if (nmax == 0 || j < nmax) { 442 if (nmax == 0 || j < nmax) {
302 /* copy the current string to the array */ 443 /* copy the current string to the array */
303 sstr_t item = sstrn(curpos.ptr, match.ptr - curpos.ptr); 444 scstr_t item = scstrn(curpos.ptr, match.ptr - curpos.ptr);
304 result[j-1] = sstrdup_a(allocator, item); 445 result[j-1] = sstrdup_a(allocator, item);
305 size_t processed = item.length + d.length; 446 size_t processed = item.length + d.length;
306 curpos.ptr += processed; 447 curpos.ptr += processed;
307 curpos.length -= processed; 448 curpos.length -= processed;
308 449
309 /* allocate memory for the next string */ 450 /* allocate memory for the next string */
310 j++; 451 j++;
311 if (j > arrlen) { 452 if (j > arrlen) {
312 arrlen *= 2; 453 arrlen *= 2;
313 sstr_t* reallocated = (sstr_t*) alrealloc( 454 size_t reallocsz;
314 allocator, result, arrlen*sizeof(sstr_t)); 455 sstr_t* reallocated = NULL;
456 if(!ucx_szmul(arrlen, sizeof(sstr_t), &reallocsz)) {
457 reallocated = (sstr_t*) alrealloc(
458 allocator, result, reallocsz);
459 }
315 if (reallocated) { 460 if (reallocated) {
316 result = reallocated; 461 result = reallocated;
317 } else { 462 } else {
318 for (ssize_t i = 0 ; i < j-1 ; i++) { 463 for (ssize_t i = 0 ; i < j-1 ; i++) {
319 alfree(allocator, result[i].ptr); 464 alfree(allocator, result[i].ptr);
340 } 485 }
341 486
342 return result; 487 return result;
343 } 488 }
344 489
345 int sstrcmp(sstr_t s1, sstr_t s2) { 490 int scstrcmp(scstr_t s1, scstr_t s2) {
346 if (s1.length == s2.length) { 491 if (s1.length == s2.length) {
347 return memcmp(s1.ptr, s2.ptr, s1.length); 492 return memcmp(s1.ptr, s2.ptr, s1.length);
348 } else if (s1.length > s2.length) { 493 } else if (s1.length > s2.length) {
349 return 1; 494 return 1;
350 } else { 495 } else {
351 return -1; 496 return -1;
352 } 497 }
353 } 498 }
354 499
355 int sstrcasecmp(sstr_t s1, sstr_t s2) { 500 int scstrcasecmp(scstr_t s1, scstr_t s2) {
356 if (s1.length == s2.length) { 501 if (s1.length == s2.length) {
357 #ifdef _WIN32 502 #ifdef _WIN32
358 return _strnicmp(s1.ptr, s2.ptr, s1.length); 503 return _strnicmp(s1.ptr, s2.ptr, s1.length);
359 #else 504 #else
360 return strncasecmp(s1.ptr, s2.ptr, s1.length); 505 return strncasecmp(s1.ptr, s2.ptr, s1.length);
364 } else { 509 } else {
365 return -1; 510 return -1;
366 } 511 }
367 } 512 }
368 513
369 sstr_t sstrdup(sstr_t s) { 514 sstr_t scstrdup(scstr_t s) {
370 return sstrdup_a(ucx_default_allocator(), s); 515 return sstrdup_a(ucx_default_allocator(), s);
371 } 516 }
372 517
373 sstr_t sstrdup_a(UcxAllocator *allocator, sstr_t s) { 518 sstr_t scstrdup_a(UcxAllocator *allocator, scstr_t s) {
374 sstr_t newstring; 519 sstr_t newstring;
375 newstring.ptr = (char*)almalloc(allocator, s.length + 1); 520 newstring.ptr = (char*)almalloc(allocator, s.length + 1);
376 if (newstring.ptr) { 521 if (newstring.ptr) {
377 newstring.length = s.length; 522 newstring.length = s.length;
378 newstring.ptr[newstring.length] = 0; 523 newstring.ptr[newstring.length] = 0;
383 } 528 }
384 529
385 return newstring; 530 return newstring;
386 } 531 }
387 532
533
534 static size_t ucx_strtrim(const char *s, size_t len, size_t *newlen) {
535 const char *newptr = s;
536 size_t length = len;
537
538 while(length > 0 && isspace(*newptr)) {
539 newptr++;
540 length--;
541 }
542 while(length > 0 && isspace(newptr[length-1])) {
543 length--;
544 }
545
546 *newlen = length;
547 return newptr - s;
548 }
549
388 sstr_t sstrtrim(sstr_t string) { 550 sstr_t sstrtrim(sstr_t string) {
389 sstr_t newstr = string; 551 sstr_t newstr;
390 552 newstr.ptr = string.ptr
391 while (newstr.length > 0 && isspace(*newstr.ptr)) { 553 + ucx_strtrim(string.ptr, string.length, &newstr.length);
392 newstr.ptr++;
393 newstr.length--;
394 }
395 while (newstr.length > 0 && isspace(newstr.ptr[newstr.length-1])) {
396 newstr.length--;
397 }
398
399 return newstr; 554 return newstr;
400 } 555 }
401 556
402 int sstrprefix(sstr_t string, sstr_t prefix) { 557 scstr_t scstrtrim(scstr_t string) {
558 scstr_t newstr;
559 newstr.ptr = string.ptr
560 + ucx_strtrim(string.ptr, string.length, &newstr.length);
561 return newstr;
562 }
563
564 int scstrprefix(scstr_t string, scstr_t prefix) {
403 if (string.length == 0) { 565 if (string.length == 0) {
404 return prefix.length == 0; 566 return prefix.length == 0;
405 } 567 }
406 if (prefix.length == 0) { 568 if (prefix.length == 0) {
407 return 1; 569 return 1;
412 } else { 574 } else {
413 return memcmp(string.ptr, prefix.ptr, prefix.length) == 0; 575 return memcmp(string.ptr, prefix.ptr, prefix.length) == 0;
414 } 576 }
415 } 577 }
416 578
417 int sstrsuffix(sstr_t string, sstr_t suffix) { 579 int scstrsuffix(scstr_t string, scstr_t suffix) {
418 if (string.length == 0) { 580 if (string.length == 0) {
419 return suffix.length == 0; 581 return suffix.length == 0;
420 } 582 }
421 if (suffix.length == 0) { 583 if (suffix.length == 0) {
422 return 1; 584 return 1;
428 return memcmp(string.ptr+string.length-suffix.length, 590 return memcmp(string.ptr+string.length-suffix.length,
429 suffix.ptr, suffix.length) == 0; 591 suffix.ptr, suffix.length) == 0;
430 } 592 }
431 } 593 }
432 594
433 sstr_t sstrlower(sstr_t string) { 595 sstr_t scstrlower(scstr_t string) {
434 sstr_t ret = sstrdup(string); 596 sstr_t ret = sstrdup(string);
435 for (size_t i = 0; i < ret.length ; i++) { 597 for (size_t i = 0; i < ret.length ; i++) {
436 ret.ptr[i] = tolower(ret.ptr[i]); 598 ret.ptr[i] = tolower(ret.ptr[i]);
437 } 599 }
438 return ret; 600 return ret;
439 } 601 }
440 602
441 sstr_t sstrlower_a(UcxAllocator *allocator, sstr_t string) { 603 sstr_t scstrlower_a(UcxAllocator *allocator, scstr_t string) {
442 sstr_t ret = sstrdup_a(allocator, string); 604 sstr_t ret = sstrdup_a(allocator, string);
443 for (size_t i = 0; i < ret.length ; i++) { 605 for (size_t i = 0; i < ret.length ; i++) {
444 ret.ptr[i] = tolower(ret.ptr[i]); 606 ret.ptr[i] = tolower(ret.ptr[i]);
445 } 607 }
446 return ret; 608 return ret;
447 } 609 }
448 610
449 sstr_t sstrupper(sstr_t string) { 611 sstr_t scstrupper(scstr_t string) {
450 sstr_t ret = sstrdup(string); 612 sstr_t ret = sstrdup(string);
451 for (size_t i = 0; i < ret.length ; i++) { 613 for (size_t i = 0; i < ret.length ; i++) {
452 ret.ptr[i] = toupper(ret.ptr[i]); 614 ret.ptr[i] = toupper(ret.ptr[i]);
453 } 615 }
454 return ret; 616 return ret;
455 } 617 }
456 618
457 sstr_t sstrupper_a(UcxAllocator *allocator, sstr_t string) { 619 sstr_t scstrupper_a(UcxAllocator *allocator, scstr_t string) {
458 sstr_t ret = sstrdup_a(allocator, string); 620 sstr_t ret = sstrdup_a(allocator, string);
459 for (size_t i = 0; i < ret.length ; i++) { 621 for (size_t i = 0; i < ret.length ; i++) {
460 ret.ptr[i] = toupper(ret.ptr[i]); 622 ret.ptr[i] = toupper(ret.ptr[i]);
461 } 623 }
462 return ret; 624 return ret;
463 } 625 }
626
627 // type adjustment functions
628 scstr_t ucx_sc2sc(scstr_t str) {
629 return str;
630 }
631 scstr_t ucx_ss2sc(sstr_t str) {
632 scstr_t cs;
633 cs.ptr = str.ptr;
634 cs.length = str.length;
635 return cs;
636 }
637 scstr_t ucx_ss2c_s(scstr_t c) {
638 return c;
639 }

Mercurial Repository: dav

mercurial