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 int 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
  43                 if (f(mid, args))
  44                         hi = mid;
  45                 else
  46                         lo = mid;
  47         }
  48
  49         if (lo)
  50                 return hi;
  51
  52         return f(0, args) ? 0 : 1;
  53 }
  54
  55 void free_names(char **a)
  56 {
  57         char **p;
  58         if (!a) {
  59                 return;
  60         }
  61         for (p = a; *p; p++) {
  62                 reftable_free(*p);
  63         }
  64         reftable_free(a);
  65 }
  66
  67 int names_length(char **names)
  68 {
  69         char **p = names;
  70         for (; *p; p++) {
  71                 /* empty */
  72         }
  73         return p - names;
  74 }
  75
  76 void parse_names(char *buf, int size, char ***namesp)
  77 {
  78         char **names = NULL;
  79         size_t names_cap = 0;
  80         size_t names_len = 0;
  81
  82         char *p = buf;
  83         char *end = buf + size;
  84         while (p < end) {
  85                 char *next = strchr(p, '\n');
  86                 if (next && next < end) {
  87                         *next = 0;
  88                 } else {
  89                         next = end;
  90                 }
  91                 if (p < next) {
  92                         if (names_len == names_cap) {
  93                                 names_cap = 2 * names_cap + 1;
  94                                 names = reftable_realloc(
  95                                         names, names_cap * sizeof(*names));
  96                         }
  97                         names[names_len++] = xstrdup(p);
  98                 }
  99                 p = next + 1;
 100         }
 101
 102         names = reftable_realloc(names, (names_len + 1) * sizeof(*names));
 103         names[names_len] = NULL;
 104         *namesp = names;
 105 }
 106
 107 int names_equal(char **a, char **b)
 108 {
 109         int i = 0;
 110         for (; a[i] && b[i]; i++) {
 111                 if (strcmp(a[i], b[i])) {
 112                         return 0;
 113                 }
 114         }
 115
 116         return a[i] == b[i];
 117 }
 118
 119 int common_prefix_size(struct strbuf *a, struct strbuf *b)
 120 {
 121         int p = 0;
 122         for (; p < a->len && p < b->len; p++) {
 123                 if (a->buf[p] != b->buf[p])
 124                         break;
 125         }
 126
 127         return p;
 128 }