ucx: ucx/string.c@88dbea299440

     1 /*

     2  * File:   sstring.c

     3  * Author: olaf

     4  *

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

     6  */

     8 #include <stdlib.h>

     9 #include <strings.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 (int 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 sstrcat(sstr_t s, ...) {

    43     va_list ap;

    44     va_start(ap, s);

    45     s.ptr[0] = 0;

    47     sstr_t str = va_arg (ap, sstr_t);

    48     while (str.ptr != NULL) {

    49         s.ptr = strncat (s.ptr, str.ptr, s.length);

    50         str = va_arg (ap, sstr_t);

    51     }

    52     va_end(ap);

    54     return s;

    55 }

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

    58     va_list ap;

    59     va_start(ap, c1);

    60     s.ptr[0] = 0;

    62     size_t len = s.length;

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

    64     char   *ptr = s.ptr;

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

    67     len -= cplen;

    68     ptr += cplen;

    69     for (int i=0;i<n-1;i++) {

    70         sstr_t str = va_arg (ap, sstr_t);

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

    72         if(cplen <= 0) {

    73             va_end(ap);

    74             return s;

    75         }

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

    77         len -= cplen;

    78         ptr += cplen;

    79     }

    80     va_end(ap);

    82     return s;

    83 }

    85 sstr_t sstrsubs(sstr_t s, size_t start) {

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

    87 }

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

    90     sstr_t new_sstr;

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

    92         return s;

    93     }

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

    95         length = s.length-start;

    96     }

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

    98     new_sstr.length = length;

    99     return new_sstr;

   100 }

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

   103     if (d.length == 0) {

   104         return NULL;

   105     }

   107     sstr_t* result;

   108     size_t nmax = *n;

   109     *n = 1;

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

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

   113         result = malloc(sizeof(sstr_t));

   114         result[0] = sstrn("", 0);

   115         return result;

   116     }

   117     sstr_t sv = sstrdup(s);

   119     for (int i = 0 ; i < s.length ; i++) {

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

   121             _Bool match = 1;

   122             for (int j = 1 ; j < d.length ; j++) {

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

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

   125                 } else {

   126                     match = 0;

   127                     break;

   128                 }

   129             }

   130             if (match) {

   131                 (*n)++;

   132                 for (int j = 0 ; j < d.length ; j++) {

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

   134                 }

   135                 i += d.length;

   136             }

   137         }

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

   139     }

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

   142     char *pptr = sv.ptr;

   143     for (int i = 0 ; i < *n ; i++) {

   144         size_t l = strlen(pptr);

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

   146         memcpy(ptr, pptr, l);

   147         ptr[l] = 0;

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

   150         pptr += l + d.length;

   151     }

   153     free(sv.ptr);

   155     return result;

   156 }

   158 int sstrcmp(sstr_t s1, sstr_t s2) {

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

   160 }

   162 sstr_t sstrdup(sstr_t s) {

   163     sstr_t newstring;

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

   165     if (newstring.ptr != NULL) {

   166         newstring.length = s.length;

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

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

   170     }

   172     return newstring;

   173 }

Mercurial > hg > ucx / file revision