mhl/string.h

   1 #ifndef __MHL_STRING_H
   2 #define __MHL_STRING_H
   3
   4 #include <ctype.h>
   5 #include <stdarg.h>
   6 #include <assert.h>
   7 #include <mhl/memory.h>
   8
   9 #define mhl_str_dup(str)        ((str ? strdup(str) : strdup("")))
  10 #define mhl_str_ndup(str,len)   ((str ? strndup(str,len) : strdup("")))
  11 #define mhl_str_len(str)        ((str ? strlen(str) : 0))
  12
  13 static inline char * mhl_str_dup_range(const char * s_start, const char * s_bound)
  14 {
  15     return mhl_str_ndup(s_start, s_bound - s_start);
  16 }
  17
  18 static inline char* mhl_str_trim(char* str)
  19 {
  20     if (!str) return NULL;      /* NULL string ?! bail out. */
  21
  22     /* find the first non-space */
  23     char* start; for (start=str; ((*str) && (!isspace(*str))); str++);
  24
  25     /* only spaces ? */
  26     if (!(*str)) { *str = 0; return str; }
  27
  28     /* get the size (cannot be empty - catched above) */
  29     size_t _sz = strlen(str);
  30
  31     /* find the proper end */
  32     char* end;
  33     for (end=(str+_sz-1); ((end>str) && (isspace(*end))); end--);
  34     end[1] = 0;         /* terminate, just to be sure */
  35
  36     /* if we have no leading spaces, just trucate */
  37     if (start==str) { end++; *end = 0; return str; }
  38
  39     /* if it' only one char, dont need memmove for that */
  40     if (start==end) { str[0]=*start; str[1]=0; return str; }
  41
  42     /* by here we have a (non-empty) region between start end end */
  43     memmove(str,start,(end-start+1));
  44     return str;
  45 }
  46
  47 static inline void mhl_str_toupper(char* str)
  48 {
  49     if (str)
  50         for (;*str;str++)
  51             *str = toupper(*str);
  52 }
  53
  54 #define __STR_CONCAT_MAX        32
  55 /* _NEVER_ call this function directly ! */
  56 static inline char* __mhl_str_concat_hlp(const char* base, ...)
  57 {
  58     static const char* arg_ptr[__STR_CONCAT_MAX];
  59     static size_t      arg_sz[__STR_CONCAT_MAX];
  60     int         count = 0;
  61     size_t      totalsize = 0;
  62
  63     if (base)
  64     {
  65         arg_ptr[0] = base;
  66         arg_sz[0]  = totalsize = strlen(base);
  67         count = 1;
  68     }
  69
  70     va_list args;
  71     va_start(args,base);
  72     char* a;
  73     /* note: we use ((char*)(1)) as terminator - NULL is a valid argument ! */
  74     while ((a = va_arg(args, char*))!=(char*)1 && count < __STR_CONCAT_MAX )
  75     {
  76         if (a)
  77         {
  78             arg_ptr[count] = a;
  79             arg_sz[count]  = strlen(a);
  80             totalsize += arg_sz[count];
  81             count++;
  82         }
  83     }
  84     va_end(args);
  85
  86     if (!count)
  87         return mhl_str_dup("");
  88
  89     /* now as we know how much to copy, allocate the buffer */
  90     char* buffer = (char*)mhl_mem_alloc_u(totalsize+2);
  91     char* current = buffer;
  92     int x=0;
  93     for (x=0; x<count; x++)
  94     {
  95         memcpy(current, arg_ptr[x], arg_sz[x]);
  96         current += arg_sz[x];
  97     }
  98
  99     *current = 0;
 100     return buffer;
 101 }
 102
 103 #define mhl_str_concat(...)     (__mhl_str_concat_hlp(__VA_ARGS__, (char*)(1)))
 104
 105 static inline char* mhl_str_reverse(char* ptr)
 106 {
 107     if (!ptr)                   return NULL;    /* missing string */
 108     if (!(ptr[0] && ptr[1]))    return ptr;     /* empty or 1-ch string */
 109
 110     size_t _sz = strlen(ptr);
 111     char* start = ptr;
 112     char* end   = ptr+_sz-1;
 113
 114     while (start<end)
 115     {
 116         char c = *start;
 117         *start = *end;
 118         *end = c;
 119         start++;
 120         end--;
 121     }
 122
 123     return ptr;
 124 }
 125
 126 /*
 127  * strcpy is unsafe on overlapping memory areas, so define memmove-alike
 128  * string function. Has sense only when dest <= src.
 129  */
 130 static inline char * mhl_strmove(char * dest, const char * src)
 131 {
 132     size_t n = strlen (src) + 1; /* + '\0' */
 133
 134     assert (dest<=src);
 135
 136     return memmove(dest, src, n);
 137 }
 138
 139 static inline char* mhl_str_dir_plus_file(const char* dirname, const char* filename)
 140 {
 141     /* make sure we have valid strings */
 142     if (!dirname)
 143         dirname="";
 144
 145     if (!filename)
 146         filename="";
 147
 148     /* skip leading slashes on filename */
 149     while (*filename == '/')
 150         filename++;
 151
 152     /* skip trailing slashes on dirname */
 153     size_t dnlen = strlen(dirname);
 154     while ((dnlen != 0) && (dirname[dnlen-1]=='/'))
 155         dnlen--;
 156
 157     size_t fnlen = strlen(filename);
 158     char* buffer = mhl_mem_alloc_z(dnlen+fnlen+2);      /* enough space for dirname, /, filename, zero */
 159     char* ptr = buffer;
 160
 161     memcpy(ptr, dirname, dnlen);
 162     ptr+=dnlen;
 163     *ptr = '/';
 164     ptr++;
 165     memcpy(ptr, filename, fnlen);
 166     ptr+=fnlen;
 167     *ptr = 0;
 168
 169     return buffer;
 170 }
 171
 172 #endif /* __MHL_STRING_H */