bstr.c

   1 #include "stdlib.h"
   2 #include "stdio.h"
   3 #include "string.h"
   4 #include "ctype.h"
   5 #include "bstr.h"
   6
   7 char *strdup(const char *str)
   8 {
   9     size_t len = strlen(str);
  10     char *new_str = malloc(len + 1);
  11     if (new_str){
  12         memcpy(new_str, str, len + 1);
  13     }
  14     return new_str;
  15 }
  16
  17 char *strndup(const char *str, size_t n)
  18 {
  19     size_t len = strnlen(str, n);
  20     char *new_str = malloc(len + 1);
  21     if (new_str){
  22         memcpy(new_str, str, len + 1);
  23     }
  24     return new_str;
  25 }
  26
  27 char *strchrnul(const char *str, int c)
  28 {
  29     const char *p = strchr(str, c);
  30     if (!p)
  31         p = (const char *) str + strlen(str);
  32     return (char *) p;
  33 }
  34
  35 char *strdcat(char **dest, const char *src)
  36 {
  37     int la, lb;
  38     char *p;
  39     la = *dest ? strlen(*dest) : 0;
  40     lb = strlen(src);
  41     p = realloc(*dest, la + lb + 1);
  42     if (!p)
  43         return NULL;
  44     *dest = p;
  45     memcpy(*dest + la, src, lb + 1);
  46     return *dest;
  47 }
  48
  49 char *strdncat(char **dest, const char *src, size_t n)
  50 {
  51     int la, lb;
  52     char *p;
  53     la = *dest ? strlen(*dest) : 0;
  54     lb = strlen(src);
  55     if (lb > n)
  56         lb = n;
  57     p = realloc(*dest, la + lb + 1);
  58     if (!p)
  59         return NULL;
  60     *dest = p;
  61     memcpy(*dest + la, src, lb);
  62     (*dest)[la + lb] = '\0';
  63     return *dest;
  64 }
  65
  66 char *strdcpy(char **dest, const char *src)
  67 {
  68     int l;
  69     char *p;
  70     l = strlen(src);
  71     p = realloc(*dest, l + 1);
  72     if (!p)
  73         return NULL;
  74     *dest = p;
  75     memcpy(*dest, src, l + 1);
  76     return *dest;
  77 }
  78
  79 char *strdncpy(char **dest, const char *src, size_t n)
  80 {
  81     int l;
  82     char *p;
  83     l = strlen(src);
  84     if (l > n)
  85         l = n;
  86     p = realloc(*dest, l + 1);
  87     if (!p)
  88         return NULL;
  89     *dest = p;
  90     memcpy(*dest, src, l);
  91     (*dest)[l] = '\0';
  92     return *dest;
  93 }
  94
  95 char *strdcatc(char **dest, int ch)
  96 {
  97     int l;
  98     char *p;
  99     l = *dest ? strlen(*dest) : 0;
 100     p = realloc(*dest, l + 2);
 101     if (!p)
 102         return NULL;
 103     *dest = p;
 104     (*dest)[l] = ch;
 105     (*dest)[l + 1] = '\0';
 106     return *dest;
 107 }
 108
 109 char *strldcat(char **dest, int *dest_len, const char *src)
 110 {
 111     int lb;
 112     char *p;
 113     lb = strlen(src);
 114     p = realloc(*dest, *dest_len + lb + 1);
 115     if (!p)
 116         return NULL;
 117     *dest = p;
 118     memcpy(*dest + *dest_len, src, lb + 1);
 119     *dest_len += lb;
 120     return *dest;
 121 }
 122
 123 char *strldncat(char **dest, int *dest_len, const char *src, size_t n)
 124 {
 125     int lb;
 126     char *p;
 127     lb = strlen(src);
 128     if (lb > n)
 129         lb = n;
 130     p = realloc(*dest, *dest_len + lb + 1);
 131     if (!p)
 132         return NULL;
 133     *dest = p;
 134     memcpy(*dest + *dest_len, src, lb);
 135     (*dest)[*dest_len + lb] = '\0';
 136     *dest_len += lb;
 137     return *dest;
 138 }
 139
 140 char *strldcpy(char **dest, int *dest_len, const char *src, int src_len)
 141 {
 142     char *p;
 143     p = realloc(*dest, src_len + 1);
 144     if (!p)
 145         return NULL;
 146     *dest = p;
 147     memcpy(*dest, src, src_len + 1);
 148     *dest_len = src_len;
 149     return *dest;
 150 }
 151
 152 char *strldncpy(char **dest, int *dest_len, const char *src, size_t n)
 153 {
 154     int l;
 155     char *p;
 156     l = strlen(src);
 157     if (l > n)
 158         l = n;
 159     p = realloc(*dest, l + 1);
 160     if (!p)
 161         return NULL;
 162     *dest = p;
 163     memcpy(*dest, src, l);
 164     (*dest)[l] = '\0';
 165     *dest_len = l;
 166     return *dest;
 167 }
 168
 169 char *strldcatc(char **dest, int *dest_len, int ch)
 170 {
 171     char *p;
 172     p = realloc(*dest, *dest_len + 2);
 173     if (!p)
 174         return NULL;
 175     *dest = p;
 176     (*dest)[*dest_len] = ch;
 177     (*dest)[*dest_len + 1] = '\0';
 178     (*dest_len)++;
 179     return *dest;
 180 }
 181
 182 char *sdprintf(const char *fmt, ...)
 183 {
 184     char *p;
 185     va_list ap;
 186     va_start(ap, fmt);
 187     p = vsdprintf(fmt, ap);
 188     va_end(ap);
 189     return p;
 190 }
 191
 192 char *vsdprintf(const char *fmt, va_list ap)
 193 {
 194     char buf[2], *p;
 195     int n;
 196     n = vsnprintf(buf, 2, fmt, ap);
 197     p = malloc(n + 1);
 198     if (!p)
 199         return NULL;
 200     vsprintf(p, fmt, ap);
 201     return p;
 202 }
 203
 204 void strtolower(char *str)
 205 {
 206     while (*str){
 207         *str = tolower(*str);
 208         str++;
 209     }
 210 }
 211
 212 void strtoupper(char *str)
 213 {
 214     while (*str){
 215         *str = toupper(*str);
 216         str++;
 217     }
 218 }
 219
 220 char *pathname(const char *str)
 221 {
 222     char *p = strrchr(str, '/');
 223     if (!p)
 224         return strdup(".");
 225     else
 226         return strndup(str, p - str);
 227 }
 228
 229 char *filesuffix(const char *str)
 230 {
 231     const char *p = str + strlen(str) - 1;
 232     while (p >= str){
 233         if (*p == '.'){
 234             // Suffix, or hidden file?
 235             if (p == str || p[-1] == '/'){
 236                 // Hidden file. :-(
 237                 return strdup("");
 238             } else {
 239                 return strdup(p + 1);
 240             }
 241         } else
 242             p--;
 243     }
 244     return strdup("");
 245 }
 246