ucx: ucx/string.c@e0ec80179a5d

     1 /*

     2  * File:   sstring.c

     3  * Author: olaf

     4  *

     5  * Created on 17. Juni 2010, 13:27

     6  */

     8 #include <stdlib.h>

     9 #include <string.h>

    10 #include <stdarg.h>

    12 #include "string.h"

    14 sstr_t sstr(char *s) {

    15     sstr_t string;

    16     string.ptr = s;

    17     string.length = strlen(s);

    18     return string;

    19 }

    21 sstr_t sstrn(char *s, size_t n) {

    22     sstr_t string;

    23     string.ptr = s;

    24     string.length = n;

    25     return string;

    26 }

    28 size_t sstrnlen(size_t n, sstr_t s, ...) {

    29     va_list ap;

    30     size_t size = s.length;

    31     va_start(ap, s);

    33     for (size_t i = 0 ; i < n-1 ; i++) {

    34         sstr_t str = va_arg(ap, sstr_t);

    35         size += str.length;

    36     }

    37     va_end(ap);

    39     return size;

    40 }

    42 sstr_t sstrncat(size_t n, sstr_t s, sstr_t c1, ...) {

    43     va_list ap;

    44     va_start(ap, c1);

    45     s.ptr[0] = 0;

    47     size_t len = s.length;

    48     size_t cplen = c1.length > len ? len : c1.length;

    49     char   *ptr = s.ptr;

    51     memcpy(ptr, c1.ptr, cplen);

    52     len -= cplen;

    53     ptr += cplen;

    54     for (size_t i = 0 ; i < n-1 ; i++) {

    55         sstr_t str = va_arg (ap, sstr_t);

    56         cplen = str.length > len ? len : str.length;

    57         if(cplen <= 0) {

    58             va_end(ap);

    59             return s;

    60         }

    61         memcpy(ptr, str.ptr, cplen);

    62         len -= cplen;

    63         ptr += cplen;

    64     }

    65     va_end(ap);

    66     s.length = ptr - s.ptr;

    68     return s;

    69 }

    71 sstr_t sstrsubs(sstr_t s, size_t start) {

    72     return sstrsubsl (s, start, s.length-start);

    73 }

    75 sstr_t sstrsubsl(sstr_t s, size_t start, size_t length) {

    76     sstr_t new_sstr;

    77     if (start < 0 || start >= s.length || length < 0) {

    78         return s;

    79     }

    80     if (length > s.length-start) {

    81         length = s.length-start;

    82     }

    83     new_sstr.ptr = &s.ptr[start];

    84     new_sstr.length = length;

    85     return new_sstr;

    86 }

    88 sstr_t* sstrsplit(sstr_t s, sstr_t d, size_t *n) {

    89     if (d.length == 0) {

    90         return NULL;

    91     }

    93     sstr_t* result;

    94     size_t nmax = *n;

    95     *n = 1;

    97     /* special case: exact match - no processing needed */

    98     if (s.length == d.length && strncmp(s.ptr, d.ptr, s.length) == 0) {

    99         *n = 0;

   100         return NULL;

   101     }

   102     sstr_t sv = sstrdup(s);

   104     for (size_t i = 0 ; i < s.length ; i++) {

   105         if (sv.ptr[i] == d.ptr[0]) {

   106             _Bool match = 1;

   107             for (size_t j = 1 ; j < d.length ; j++) {

   108                 if (j+i < s.length) {

   109                     match &= (sv.ptr[i+j] == d.ptr[j]);

   110                 } else {

   111                     match = 0;

   112                     break;

   113                 }

   114             }

   115             if (match) {

   116                 (*n)++;

   117                 for (size_t j = 0 ; j < d.length ; j++) {

   118                     sv.ptr[i+j] = 0;

   119                 }

   120                 i += d.length;

   121             }

   122         }

   123         if ((*n) == nmax) break;

   124     }

   125     result = (sstr_t*) malloc(sizeof(sstr_t) * (*n));

   127     char *pptr = sv.ptr;

   128     for (size_t i = 0 ; i < *n ; i++) {

   129         size_t l = strlen(pptr);

   130         char* ptr = (char*) malloc(l + 1);

   131         memcpy(ptr, pptr, l);

   132         ptr[l] = 0;

   134         result[i] = sstrn(ptr, l);

   135         pptr += l + d.length;

   136     }

   138     free(sv.ptr);

   140     return result;

   141 }

   143 int sstrcmp(sstr_t s1, sstr_t s2) {

   144     return strncmp(s1.ptr, s2.ptr, s1.length>s2.length ? s2.length: s1.length);

   145 }

   147 sstr_t sstrdup(sstr_t s) {

   148     sstr_t newstring;

   149     newstring.ptr = (char*) malloc(s.length + 1);

   150     newstring.length = 0;

   151     if (newstring.ptr) {

   152         newstring.length = s.length;

   153         newstring.ptr[newstring.length] = 0;

   155         memcpy(newstring.ptr, s.ptr, s.length);

   156     } else {

   157         newstring.length = 0;

   158     }

   160     return newstring;

   161 }

   163 sstr_t sstrtrim(sstr_t string) {

   164     sstr_t newstr = string;

   165     if (string.length == 0) {

   166         return newstr;

   167     }

   169     size_t i;

   170     for(i=0;i<string.length;i++) {

   171         char c = string.ptr[i];

   172         if(c > 32) {

   173             break;

   174         }

   175     }

   176     newstr.ptr = &string.ptr[i];

   177     newstr.length = string.length - i;

   179     for(i=newstr.length-1;i>=0;i--) {

   180         char c = newstr.ptr[i];

   181         if(c > 32) {

   182             break;

   183         }

   184     }

   185     newstr.length = i + 1;

   187     return newstr;

   188 }

Mercurial > hg > ucx / file revision