comparison: ucx/string.c
ucx/string.c
- changeset 233
- bd58fdde142d
- parent 231
- 35490eb48214
- child 234
- 7a63b4986b5b
equal
deleted
inserted
replaced
| 232:5f2d650eade7 | 233:bd58fdde142d |
|---|---|
| 210 *n = 0; | 210 *n = 0; |
| 211 return NULL; | 211 return NULL; |
| 212 } else /* no match possible */ { | 212 } else /* no match possible */ { |
| 213 *n = 1; | 213 *n = 1; |
| 214 sstr_t *result = (sstr_t*) almalloc(allocator, sizeof(sstr_t)); | 214 sstr_t *result = (sstr_t*) almalloc(allocator, sizeof(sstr_t)); |
| 215 result->ptr = (char*) almalloc(allocator, 1+s.length); | 215 *result = sstrdup_a(allocator, s); |
| 216 memcpy(result->ptr, s.ptr, s.length); | |
| 217 result->ptr[s.length] = '\0'; | |
| 218 result->length = s.length; | |
| 219 return result; | 216 return result; |
| 220 } | 217 } |
| 221 } | 218 } |
| 222 | 219 |
| 223 sstr_t* result; | |
| 224 ssize_t nmax = *n; | 220 ssize_t nmax = *n; |
| 225 *n = 1; | 221 sstr_t* result = (sstr_t*) almalloc(allocator, sizeof(sstr_t)); |
| 226 | |
| 227 sstr_t sv = sstrdup(s); | |
| 228 if (sv.length == 0) { | |
| 229 *n = -2; | |
| 230 return NULL; | |
| 231 } | |
| 232 | |
| 233 for (size_t i = 0 ; i < s.length ; i++) { | |
| 234 sstr_t substr = sstrsubs(sv, i); | |
| 235 if (sstrprefix(substr, d)) { | |
| 236 (*n)++; | |
| 237 for (size_t j = 0 ; j < d.length ; j++) { | |
| 238 sv.ptr[i+j] = 0; | |
| 239 } | |
| 240 i += d.length - 1; // -1, because the loop will do a i++ | |
| 241 } | |
| 242 if ((*n) == nmax) break; | |
| 243 } | |
| 244 result = (sstr_t*) almalloc(allocator, sizeof(sstr_t)*(*n)); | |
| 245 | 222 |
| 246 if (result) { | 223 if (result) { |
| 247 char *pptr = sv.ptr; | 224 sstr_t curpos = s; |
| 248 for (ssize_t i = 0 ; i < *n ; i++) { | 225 ssize_t j = 1; |
| 249 size_t l = strlen(pptr); | 226 while (1) { |
| 250 char* ptr = (char*) almalloc(allocator, l + 1); | 227 sstr_t match = sstrstr(curpos, d); |
| 251 if (ptr) { | 228 if (match.length > 0) { |
| 252 memcpy(ptr, pptr, l); | 229 /* is this our last try? */ |
| 253 ptr[l] = '\0'; | 230 if (nmax == 0 || j < nmax) { |
| 254 | 231 /* copy the current string to the array */ |
| 255 result[i] = sstrn(ptr, l); | 232 sstr_t item = sstrn(curpos.ptr, match.ptr - curpos.ptr); |
| 256 pptr += l + d.length; | 233 result[j-1] = sstrdup_a(allocator, item); |
| 234 size_t processed = item.length + d.length; | |
| 235 curpos.ptr += processed; | |
| 236 curpos.length -= processed; | |
| 237 | |
| 238 /* allocate memory for the next string */ | |
| 239 j++; | |
| 240 sstr_t* reallocated = (sstr_t*) | |
| 241 alrealloc(allocator, result, j*sizeof(sstr_t)); | |
| 242 if (reallocated) { | |
| 243 result = reallocated; | |
| 244 } else { | |
| 245 for (ssize_t i = 0 ; i < j-1 ; i++) { | |
| 246 alfree(allocator, result[i].ptr); | |
| 247 } | |
| 248 alfree(allocator, result); | |
| 249 *n = -2; | |
| 250 return NULL; | |
| 251 } | |
| 252 } else { | |
| 253 /* nmax reached, copy the _full_ remaining string */ | |
| 254 result[j-1] = sstrdup_a(allocator, curpos); | |
| 255 break; | |
| 256 } | |
| 257 } else { | 257 } else { |
| 258 for (ssize_t j = i-1 ; j >= 0 ; j--) { | 258 /* no more matches, copy last string */ |
| 259 alfree(allocator, result[j].ptr); | 259 result[j-1] = sstrdup_a(allocator, curpos); |
| 260 } | |
| 261 alfree(allocator, result); | |
| 262 *n = -2; | |
| 263 break; | 260 break; |
| 264 } | 261 } |
| 265 } | 262 } |
| 263 *n = j; | |
| 266 } else { | 264 } else { |
| 267 *n = -2; | 265 *n = -2; |
| 268 } | 266 } |
| 269 | |
| 270 free(sv.ptr); | |
| 271 | 267 |
| 272 return result; | 268 return result; |
| 273 } | 269 } |
| 274 | 270 |
| 275 int sstrcmp(sstr_t s1, sstr_t s2) { | 271 int sstrcmp(sstr_t s1, sstr_t s2) { |
