lint: fix code for clang-tidy

src/util.c

@@ -12,8 +12,8 @@
 static int selret_magic();
 
 int find_keyname(enum keys* at, const char* name) {
-  for (size_t i = 0; i < sizeof(key_mappings) / sizeof(key_mappings[0]); i++) {
-    if (strcmp(key_names[i], name) == 0) {
+  for (size_t i = 0; i < LEN(KEY_MAPPINGS); i++) {
+    if (strcmp(KEY_NAMES[i], name) == 0) {
       *at = (enum keys)i;
       return 0;
     }
@@ -23,8 +23,8 @@ int find_keyname(enum keys* at, const char* name) {
 }
 
 enum keys find_ansi(const char* seq) {
-  for (size_t i = 0; i < sizeof(key_mappings) / sizeof(key_mappings[0]); i++) {
-    struct key_mapping mapping = key_mappings[i];
+  for (size_t i = 0; i < LEN(KEY_MAPPINGS); i++) {
+    struct key_mapping mapping = KEY_MAPPINGS[i];
     for (size_t j = 0; mapping.sequences[j] != NULL; j++) {
       if (strcmp(mapping.sequences[j], seq) == 0) {
         return (enum keys)i;
@@ -115,72 +115,72 @@ const struct Vector VEC_NEW = {
     .pages = NULL,
 };
 
-int vec_resize(struct Vector* vec, size_t size) {
-  void** new_location = realloc(vec->pages, size * sizeof(void*));
+int vec_resize(struct Vector* self, size_t size) {
+  void** new_location =
+      (void**)realloc((void*)self->pages, size * sizeof(void*));
   if (new_location != NULL) {
-    if (vec->length > size) vec->length = size;
-    vec->capacity = size;
-    vec->pages = new_location;
+    if (self->length > size) self->length = size;
+    self->capacity = size;
+    self->pages = new_location;
   } else {
     return -1;
   }
   return 0;
 }
 
-int vec_reserve(struct Vector* vec, size_t size) {
-  uint32_t new_capacity = vec->capacity;
-  while (vec->length + size > new_capacity) {
+int vec_reserve(struct Vector* self, size_t size) {
+  uint32_t new_capacity = self->capacity;
+  while (self->length + size > new_capacity) {
     new_capacity = new_capacity + (new_capacity >> 1) +
                    1; // cap * 1.5 + 1; 0 1 2 4 7 11...
   }
-  return vec_resize(vec, new_capacity);
+  return vec_resize(self, new_capacity);
 }
 
-int vec_reserve_exact(struct Vector* vec, size_t size) {
-  uint32_t needed_capacity = vec->length + size;
-  if (vec->capacity < needed_capacity) {
-    return vec_resize(vec, needed_capacity);
-  } else {
-    return 0;
+int vec_reserve_exact(struct Vector* self, size_t size) {
+  uint32_t needed_capacity = self->length + size;
+  if (self->capacity < needed_capacity) {
+    return vec_resize(self, needed_capacity);
   }
-}
-
-int vec_push(struct Vector* vec, void* item) {
-  int res_ret = vec_reserve(vec, 1);
-  if (res_ret != 0) return res_ret;
-
-  vec->pages[vec->length++] = item;
   return 0;
 }
 
-void vec_free(struct Vector* vec) {
-  while (vec->length > 0)
-    free(vec->pages[--vec->length]);
+int vec_push(struct Vector* self, void* item) {
+  int res_ret = vec_reserve(self, 1);
+  if (res_ret != 0) return res_ret;
 
-  vec_clear(vec);
+  self->pages[self->length++] = item;
+  return 0;
 }
 
-void vec_clear(struct Vector* vec) {
-  free(vec->pages);
-  vec_reset(vec);
+void vec_free(struct Vector* self) {
+  while (self->length > 0)
+    free(self->pages[--self->length]);
+
+  vec_clear(self);
 }
 
-void vec_reset(struct Vector* vec) {
-  *vec = (struct Vector){
+void vec_clear(struct Vector* self) {
+  free((void*)self->pages);
+  vec_reset(self);
+}
+
+void vec_reset(struct Vector* self) {
+  *self = (struct Vector){
       .length = 0,
       .capacity = 0,
       .pages = NULL,
   };
 }
 
-void* vec_pop(struct Vector* vec) {
-  if (vec->length == 0) return NULL;
+void* vec_pop(struct Vector* self) {
+  if (self->length == 0) return NULL;
 
-  return vec->pages[--vec->length];
+  return self->pages[--self->length];
 }
 
-void* vec_get(struct Vector* vec, size_t index) {
-  if (index >= vec->length) return NULL;
+void* vec_get(struct Vector* self, size_t index) {
+  if (index >= self->length) return NULL;
 
-  return vec->pages[index];
+  return self->pages[index];
 }