src/TortoisePlink/utils/ptrlen.c

   1 /*
   2  * Functions to deal with ptrlens.
   3  */
   4
   5 #include "defs.h"
   6 #include "misc.h"
   7
   8 bool ptrlen_eq_string(ptrlen pl, const char *str)
   9 {
  10     size_t len = strlen(str);
  11     return (pl.len == len && !memcmp(pl.ptr, str, len));
  12 }
  13
  14 bool ptrlen_eq_ptrlen(ptrlen pl1, ptrlen pl2)
  15 {
  16     return (pl1.len == pl2.len && !memcmp(pl1.ptr, pl2.ptr, pl1.len));
  17 }
  18
  19 int ptrlen_strcmp(ptrlen pl1, ptrlen pl2)
  20 {
  21     size_t minlen = pl1.len < pl2.len ? pl1.len : pl2.len;
  22     if (minlen) {  /* tolerate plX.ptr==NULL as long as plX.len==0 */
  23         int cmp = memcmp(pl1.ptr, pl2.ptr, minlen);
  24         if (cmp)
  25             return cmp;
  26     }
  27     return pl1.len < pl2.len ? -1 : pl1.len > pl2.len ? +1 : 0;
  28 }
  29
  30 bool ptrlen_startswith(ptrlen whole, ptrlen prefix, ptrlen *tail)
  31 {
  32     if (whole.len >= prefix.len &&
  33         !memcmp(whole.ptr, prefix.ptr, prefix.len)) {
  34         if (tail) {
  35             tail->ptr = (const char *)whole.ptr + prefix.len;
  36             tail->len = whole.len - prefix.len;
  37         }
  38         return true;
  39     }
  40     return false;
  41 }
  42
  43 bool ptrlen_endswith(ptrlen whole, ptrlen suffix, ptrlen *tail)
  44 {
  45     if (whole.len >= suffix.len &&
  46         !memcmp((char *)whole.ptr + (whole.len - suffix.len),
  47                 suffix.ptr, suffix.len)) {
  48         if (tail) {
  49             tail->ptr = whole.ptr;
  50             tail->len = whole.len - suffix.len;
  51         }
  52         return true;
  53     }
  54     return false;
  55 }
  56
  57 bool ptrlen_contains(ptrlen input, const char *characters)
  58 {
  59     for (const char *p = input.ptr, *end = p + input.len; p < end; p++)
  60         if (strchr(characters, *p))
  61             return true;
  62     return false;
  63 }
  64
  65 bool ptrlen_contains_only(ptrlen input, const char *characters)
  66 {
  67     for (const char *p = input.ptr, *end = p + input.len; p < end; p++)
  68         if (!strchr(characters, *p))
  69             return false;
  70     return true;
  71 }
  72
  73 ptrlen ptrlen_get_word(ptrlen *input, const char *separators)
  74 {
  75     const char *p = input->ptr, *end = p + input->len;
  76     ptrlen toret;
  77
  78     while (p < end && strchr(separators, *p))
  79         p++;
  80     toret.ptr = p;
  81     while (p < end && !strchr(separators, *p))
  82         p++;
  83     toret.len = p - (const char *)toret.ptr;
  84
  85     size_t to_consume = p - (const char *)input->ptr;
  86     assert(to_consume <= input->len);
  87     input->ptr = (const char *)input->ptr + to_consume;
  88     input->len -= to_consume;
  89
  90     return toret;
  91 }
  92
  93 char *mkstr(ptrlen pl)
  94 {
  95     char *p = snewn(pl.len + 1, char);
  96     memcpy(p, pl.ptr, pl.len);
  97     p[pl.len] = '\0';
  98     return p;
  99 }
 100
 101 bool strstartswith(const char *s, const char *t)
 102 {
 103     return !strncmp(s, t, strlen(t));
 104 }
 105
 106 bool strendswith(const char *s, const char *t)
 107 {
 108     size_t slen = strlen(s), tlen = strlen(t);
 109     return slen >= tlen && !strcmp(s + (slen - tlen), t);
 110 }