ucx: ucx/string.c@bf8ab7bb74ff

     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     s.ptr = strncat (s.ptr, c1.ptr, s.length);

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

    64         sstr_t str = va_arg (ap, sstr_t);

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

    66     }

    67     va_end(ap);

    69     return s;

    70 }

    72 sstr_t sstrsubs (sstr_t s, size_t start) {

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

    74 }

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

    77     sstr_t new_sstr;

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

    79         return s;

    80     }

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

    82         length = s.length-start;

    83     }

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

    85     new_sstr.length = length;

    86     return new_sstr;

    87 }

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

    90     if (d.length == 0) {

    91         return NULL;

    92     }

    94     sstr_t* result;

    95     size_t nmax = *n;

    96     *n = 1;

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

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

   100         result = malloc(sizeof(sstr_t));

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

   102         return result;

   103     }

   104     sstr_t sv = sstrdup(s);

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

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

   108             _Bool match = 1;

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

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

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

   112                 } else {

   113                     match = 0;

   114                     break;

   115                 }

   116             }

   117             if (match) {

   118                 (*n)++;

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

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

   121                 }

   122                 i += d.length;

   123             }

   124         }

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

   126     }

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

   129     char *pptr = sv.ptr;

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

   131         size_t l = strlen(pptr);

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

   133         memcpy(ptr, pptr, l);

   134         ptr[l] = 0;

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

   137         pptr += l + d.length;

   138     }

   140     free(sv.ptr);

   142     return result;

   143 }

   145 int sstrcmp(sstr_t s1, sstr_t s2) {

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

   147 }

   149 sstr_t sstrdup(sstr_t s) {

   150     sstr_t newstring;

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

   152     if (newstring.ptr != NULL) {

   153         newstring.length = s.length;

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

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

   157     }

   159     return newstring;

   160 }

Mercurial > hg > ucx / file revision