comparison: ucx/string.c
ucx/string.c
- changeset 119
- baa839a7633f
- parent 116
- 234920008754
- child 120
- 8170f658f017
equal
deleted
inserted
replaced
| 118:151f5345f303 | 119:baa839a7633f |
|---|---|
| 71 char *ptr = s.ptr; | 71 char *ptr = s.ptr; |
| 72 | 72 |
| 73 memcpy(ptr, c1.ptr, cplen); | 73 memcpy(ptr, c1.ptr, cplen); |
| 74 len -= cplen; | 74 len -= cplen; |
| 75 ptr += cplen; | 75 ptr += cplen; |
| 76 for (size_t i = 0 ; i < n-1 ; i++) { | 76 for (size_t i = 1 ; i < n ; i++) { |
| 77 sstr_t str = va_arg (ap, sstr_t); | 77 sstr_t str = va_arg (ap, sstr_t); |
| 78 cplen = str.length > len ? len : str.length; | 78 cplen = str.length > len ? len : str.length; |
| 79 if(cplen <= 0) { | 79 if(cplen <= 0) { |
| 80 va_end(ap); | 80 va_end(ap); |
| 81 return s; | 81 return s; |
| 118 n.length = 0; | 118 n.length = 0; |
| 119 return n; | 119 return n; |
| 120 } | 120 } |
| 121 | 121 |
| 122 sstr_t* sstrsplit(sstr_t s, sstr_t d, size_t *n) { | 122 sstr_t* sstrsplit(sstr_t s, sstr_t d, size_t *n) { |
| 123 if (d.length == 0) { | 123 return sstrsplita(s, d, n, ucx_default_allocator()); |
| 124 } | |
| 125 | |
| 126 sstr_t* sstrsplita(sstr_t s, sstr_t d, size_t *n, UcxAllocator *allocator) { | |
| 127 if (s.length == 0 || d.length == 0) { | |
| 128 *n = -1; | |
| 124 return NULL; | 129 return NULL; |
| 125 } | 130 } |
| 126 | 131 |
| 127 sstr_t* result; | 132 sstr_t* result; |
| 128 size_t nmax = *n; | 133 size_t nmax = *n; |
| 129 *n = 1; | 134 *n = 1; |
| 130 | 135 |
| 131 /* special case: exact match - no processing needed */ | 136 /* special case: exact match - no processing needed */ |
| 132 if (s.length == d.length && strncmp(s.ptr, d.ptr, s.length) == 0) { | 137 if (sstrcmp(s, d) == 0) { |
| 133 *n = 0; | 138 *n = 0; |
| 134 return NULL; | 139 return NULL; |
| 135 } | 140 } |
| 136 sstr_t sv = sstrdup(s); | 141 sstr_t sv = sstrdup(s); |
| 142 if (sv.length == 0) { | |
| 143 *n = -2; | |
| 144 return NULL; | |
| 145 } | |
| 137 | 146 |
| 138 for (size_t i = 0 ; i < s.length ; i++) { | 147 for (size_t i = 0 ; i < s.length ; i++) { |
| 139 if (sv.ptr[i] == d.ptr[0]) { | 148 if (sv.ptr[i] == d.ptr[0]) { |
| 140 _Bool match = 1; | 149 _Bool match = 1; |
| 141 for (size_t j = 1 ; j < d.length ; j++) { | 150 for (size_t j = 1 ; j < d.length ; j++) { |
| 154 i += d.length; | 163 i += d.length; |
| 155 } | 164 } |
| 156 } | 165 } |
| 157 if ((*n) == nmax) break; | 166 if ((*n) == nmax) break; |
| 158 } | 167 } |
| 159 result = (sstr_t*) malloc(sizeof(sstr_t) * (*n)); | 168 result = (sstr_t*) allocator->malloc(sizeof(sstr_t) * (*n)); |
| 160 | 169 |
| 161 char *pptr = sv.ptr; | 170 if (result) { |
| 162 for (size_t i = 0 ; i < *n ; i++) { | 171 char *pptr = sv.ptr; |
| 163 size_t l = strlen(pptr); | 172 for (size_t i = 0 ; i < *n ; i++) { |
| 164 char* ptr = (char*) malloc(l + 1); | 173 size_t l = strlen(pptr); |
| 165 memcpy(ptr, pptr, l); | 174 char* ptr = (char*) allocator->malloc(l + 1); |
| 166 ptr[l] = 0; | 175 memcpy(ptr, pptr, l); |
| 167 | 176 ptr[l] = 0; |
| 168 result[i] = sstrn(ptr, l); | 177 |
| 169 pptr += l + d.length; | 178 result[i] = sstrn(ptr, l); |
| 170 } | 179 pptr += l + d.length; |
| 171 | 180 } |
| 181 } else { | |
| 182 *n = -2; | |
| 183 } | |
| 184 | |
| 172 free(sv.ptr); | 185 free(sv.ptr); |
| 173 | 186 |
| 174 return result; | 187 return result; |
| 175 } | 188 } |
| 176 | 189 |
