bstr.c

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