ucx: ucx/string.c@0a752853f792

     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 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 (size_t 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         *n = 0;

   114         return NULL;

   115     }

   116     sstr_t sv = sstrdup(s);

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

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

   120             _Bool match = 1;

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

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

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

   124                 } else {

   125                     match = 0;

   126                     break;

   127                 }

   128             }

   129             if (match) {

   130                 (*n)++;

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

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

   133                 }

   134                 i += d.length;

   135             }

   136         }

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

   138     }

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

   141     char *pptr = sv.ptr;

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

   143         size_t l = strlen(pptr);

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

   145         memcpy(ptr, pptr, l);

   146         ptr[l] = 0;

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

   149         pptr += l + d.length;

   150     }

   152     free(sv.ptr);

   154     return result;

   155 }

   157 int sstrcmp(sstr_t s1, sstr_t s2) {

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

   159 }

   161 sstr_t sstrdup(sstr_t s) {

   162     sstr_t newstring;

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

   164     newstring.length = 0;

   165     if (newstring.ptr) {

   166         newstring.length = s.length;

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

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

   170     } else {

   171         newstring.length = 0;

   172     }

   174     return newstring;

   175 }

   177 sstr_t sstrtrim(sstr_t string) {

   178     sstr_t newstr = string;

   179     if (string.length == 0) {

   180         return newstr;

   181     }

   183     size_t i;

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

   185         char c = string.ptr[i];

   186         if(c > 32) {

   187             break;

   188         }

   189     }

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

   191     newstr.length = string.length - i;

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

   194         char c = newstr.ptr[i];

   195         if(c > 32) {

   196             break;

   197         }

   198     }

   199     newstr.length = i + 1;

   201     return newstr;

   202 }

Mercurial > hg > ucx / file revision