reftable/basics.c

   1 /*
   2 Copyright 2020 Google LLC
   3
   4 Use of this source code is governed by a BSD-style
   5 license that can be found in the LICENSE file or at
   6 https://developers.google.com/open-source/licenses/bsd
   7 */
   8
   9 #include "basics.h"
  10
  11 void put_be24(uint8_t *out, uint32_t i)
  12 {
  13         out[0] = (uint8_t)((i >> 16) & 0xff);
  14         out[1] = (uint8_t)((i >> 8) & 0xff);
  15         out[2] = (uint8_t)(i & 0xff);
  16 }
  17
  18 uint32_t get_be24(uint8_t *in)
  19 {
  20         return (uint32_t)(in[0]) << 16 | (uint32_t)(in[1]) << 8 |
  21                (uint32_t)(in[2]);
  22 }
  23
  24 void put_be16(uint8_t *out, uint16_t i)
  25 {
  26         out[0] = (uint8_t)((i >> 8) & 0xff);
  27         out[1] = (uint8_t)(i & 0xff);
  28 }
  29
  30 size_t binsearch(size_t sz, int (*f)(size_t k, void *args), void *args)
  31 {
  32         size_t lo = 0;
  33         size_t hi = sz;
  34
  35         /* Invariants:
  36          *
  37          *  (hi == sz) || f(hi) == true
  38          *  (lo == 0 && f(0) == true) || fi(lo) == false
  39          */
  40         while (hi - lo > 1) {
  41                 size_t mid = lo + (hi - lo) / 2;
  42                 int ret = f(mid, args);
  43                 if (ret < 0)
  44                         return sz;
  45
  46                 if (ret > 0)
  47                         hi = mid;
  48                 else
  49                         lo = mid;
  50         }
  51
  52         if (lo)
  53                 return hi;
  54
  55         return f(0, args) ? 0 : 1;
  56 }
  57
  58 void free_names(char **a)
  59 {
  60         char **p;
  61         if (!a) {
  62                 return;
  63         }
  64         for (p = a; *p; p++) {
  65                 reftable_free(*p);
  66         }
  67         reftable_free(a);
  68 }
  69
  70 size_t names_length(const char **names)
  71 {
  72         const char **p = names;
  73         while (*p)
  74                 p++;
  75         return p - names;
  76 }
  77
  78 void parse_names(char *buf, int size, char ***namesp)
  79 {
  80         char **names = NULL;
  81         size_t names_cap = 0;
  82         size_t names_len = 0;
  83
  84         char *p = buf;
  85         char *end = buf + size;
  86         while (p < end) {
  87                 char *next = strchr(p, '\n');
  88                 if (next && next < end) {
  89                         *next = 0;
  90                 } else {
  91                         next = end;
  92                 }
  93                 if (p < next) {
  94                         REFTABLE_ALLOC_GROW(names, names_len + 1, names_cap);
  95                         names[names_len++] = xstrdup(p);
  96                 }
  97                 p = next + 1;
  98         }
  99
 100         REFTABLE_REALLOC_ARRAY(names, names_len + 1);
 101         names[names_len] = NULL;
 102         *namesp = names;
 103 }
 104
 105 int names_equal(const char **a, const char **b)
 106 {
 107         size_t i = 0;
 108         for (; a[i] && b[i]; i++)
 109                 if (strcmp(a[i], b[i]))
 110                         return 0;
 111         return a[i] == b[i];
 112 }
 113
 114 int common_prefix_size(struct strbuf *a, struct strbuf *b)
 115 {
 116         int p = 0;
 117         for (; p < a->len && p < b->len; p++) {
 118                 if (a->buf[p] != b->buf[p])
 119                         break;
 120         }
 121
 122         return p;
 123 }