Merge pull request #27520 from bfredl/metaarena

refactor(api): use arena for metadata; msgpack_rpc_to_object delenda est

1 files changed, 0 insertions, 229 deletions

diff --git a/src/nvim/msgpack_rpc/helpers.c b/src/nvim/msgpack_rpc/helpers.c
index 6caf50d319..c0c519848c 100644
--- a/src/nvim/msgpack_rpc/helpers.c
+++ b/src/nvim/msgpack_rpc/helpers.c
@@ -36,237 +36,8 @@ void msgpack_rpc_helpers_free_all_mem(void)
 }
 #endif
 
-typedef struct {
-  const msgpack_object *mobj;
-  Object *aobj;
-  bool container;
-  size_t idx;
-} MPToAPIObjectStackItem;
-
 // uncrustify:off
 
-/// Convert type used by msgpack parser to Nvim API type.
-///
-/// @param[in]  obj  Msgpack value to convert.
-/// @param[out]  arg  Location where result of conversion will be saved.
-///
-/// @return true in case of success, false otherwise.
-bool msgpack_rpc_to_object(const msgpack_object *const obj, Object *const arg)
-  FUNC_ATTR_NONNULL_ALL
-{
-  bool ret = true;
-  kvec_withinit_t(MPToAPIObjectStackItem, 2) stack = KV_INITIAL_VALUE;
-  kvi_init(stack);
-  kvi_push(stack, ((MPToAPIObjectStackItem) {
-    .mobj = obj,
-    .aobj = arg,
-    .container = false,
-    .idx = 0,
-  }));
-  while (ret && kv_size(stack)) {
-    MPToAPIObjectStackItem cur = kv_last(stack);
-    if (!cur.container) {
-      *cur.aobj = NIL;
-    }
-    switch (cur.mobj->type) {
-    case MSGPACK_OBJECT_NIL:
-      break;
-    case MSGPACK_OBJECT_BOOLEAN:
-      *cur.aobj = BOOLEAN_OBJ(cur.mobj->via.boolean);
-      break;
-    case MSGPACK_OBJECT_NEGATIVE_INTEGER:
-      STATIC_ASSERT(sizeof(Integer) == sizeof(cur.mobj->via.i64),
-                    "Msgpack integer size does not match API integer");
-      *cur.aobj = INTEGER_OBJ(cur.mobj->via.i64);
-      break;
-    case MSGPACK_OBJECT_POSITIVE_INTEGER:
-      STATIC_ASSERT(sizeof(Integer) == sizeof(cur.mobj->via.u64),
-                    "Msgpack integer size does not match API integer");
-      if (cur.mobj->via.u64 > API_INTEGER_MAX) {
-        ret = false;
-      } else {
-        *cur.aobj = INTEGER_OBJ((Integer)cur.mobj->via.u64);
-      }
-      break;
-    case MSGPACK_OBJECT_FLOAT32:
-    case MSGPACK_OBJECT_FLOAT64:
-    {
-      STATIC_ASSERT(sizeof(Float) == sizeof(cur.mobj->via.f64),
-                    "Msgpack floating-point size does not match API integer");
-      *cur.aobj = FLOAT_OBJ(cur.mobj->via.f64);
-      break;
-    }
-#define STR_CASE(type, attr, obj, dest, conv) \
-  case type: { \
-      dest = conv(((String) { \
-      .size = obj->via.attr.size, \
-      .data = (obj->via.attr.ptr == NULL || obj->via.attr.size == 0 \
-               ? xmemdupz("", 0) \
-               : xmemdupz(obj->via.attr.ptr, obj->via.attr.size)), })); \
-      break; \
-  }
-      STR_CASE(MSGPACK_OBJECT_STR, str, cur.mobj, *cur.aobj, STRING_OBJ)
-      STR_CASE(MSGPACK_OBJECT_BIN, bin, cur.mobj, *cur.aobj, STRING_OBJ)
-    case MSGPACK_OBJECT_ARRAY: {
-      const size_t size = cur.mobj->via.array.size;
-      if (cur.container) {
-        if (cur.idx >= size) {
-          (void)kv_pop(stack);
-        } else {
-          const size_t idx = cur.idx;
-          cur.idx++;
-          kv_last(stack) = cur;
-          kvi_push(stack, ((MPToAPIObjectStackItem) {
-              .mobj = &cur.mobj->via.array.ptr[idx],
-              .aobj = &cur.aobj->data.array.items[idx],
-              .container = false,
-          }));
-        }
-      } else {
-        *cur.aobj = ARRAY_OBJ(((Array) {
-            .size = size,
-            .capacity = size,
-            .items = (size > 0
-                      ? xcalloc(size, sizeof(*cur.aobj->data.array.items))
-                      : NULL),
-        }));
-        cur.container = true;
-        kv_last(stack) = cur;
-      }
-      break;
-    }
-    case MSGPACK_OBJECT_MAP: {
-      const size_t size = cur.mobj->via.map.size;
-      if (cur.container) {
-        if (cur.idx >= size) {
-          (void)kv_pop(stack);
-        } else {
-          const size_t idx = cur.idx;
-          cur.idx++;
-          kv_last(stack) = cur;
-          const msgpack_object *const key = &cur.mobj->via.map.ptr[idx].key;
-          switch (key->type) {
-#define ID(x) x
-          STR_CASE(MSGPACK_OBJECT_STR, str, key,
-                   cur.aobj->data.dictionary.items[idx].key, ID)
-          STR_CASE(MSGPACK_OBJECT_BIN, bin, key,
-                   cur.aobj->data.dictionary.items[idx].key, ID)
-#undef ID
-          case MSGPACK_OBJECT_NIL:
-          case MSGPACK_OBJECT_BOOLEAN:
-          case MSGPACK_OBJECT_POSITIVE_INTEGER:
-          case MSGPACK_OBJECT_NEGATIVE_INTEGER:
-          case MSGPACK_OBJECT_FLOAT32:
-          case MSGPACK_OBJECT_FLOAT64:
-          case MSGPACK_OBJECT_EXT:
-          case MSGPACK_OBJECT_MAP:
-          case MSGPACK_OBJECT_ARRAY:
-            ret = false;
-            break;
-          }
-          if (ret) {
-            kvi_push(stack, ((MPToAPIObjectStackItem) {
-                .mobj = &cur.mobj->via.map.ptr[idx].val,
-                .aobj = &cur.aobj->data.dictionary.items[idx].value,
-                .container = false,
-            }));
-          }
-        }
-      } else {
-        *cur.aobj = DICTIONARY_OBJ(((Dictionary) {
-            .size = size,
-            .capacity = size,
-            .items = (size > 0
-                      ? xcalloc(size, sizeof(*cur.aobj->data.dictionary.items))
-                      : NULL),
-        }));
-        cur.container = true;
-        kv_last(stack) = cur;
-      }
-      break;
-    }
-    case MSGPACK_OBJECT_EXT:
-      if (0 <= cur.mobj->via.ext.type && cur.mobj->via.ext.type <= EXT_OBJECT_TYPE_MAX) {
-        cur.aobj->type = (ObjectType)(cur.mobj->via.ext.type + EXT_OBJECT_TYPE_SHIFT);
-        msgpack_object data;
-        msgpack_unpack_return status = msgpack_unpack(cur.mobj->via.ext.ptr, cur.mobj->via.ext.size,
-                                                      NULL, &zone, &data);
-
-        if (status != MSGPACK_UNPACK_SUCCESS || data.type != MSGPACK_OBJECT_POSITIVE_INTEGER) {
-          ret = false;
-          break;
-        }
-        cur.aobj->data.integer = (handle_T)data.via.i64;
-        ret = true;
-      }
-      break;
-#undef STR_CASE
-    }
-    if (!cur.container) {
-      (void)kv_pop(stack);
-    }
-  }
-  kvi_destroy(stack);
-  return ret;
-}
-
-static bool msgpack_rpc_to_string(const msgpack_object *const obj, String *const arg)
-  FUNC_ATTR_NONNULL_ALL
-{
-  if (obj->type == MSGPACK_OBJECT_BIN || obj->type == MSGPACK_OBJECT_STR) {
-    arg->data = obj->via.bin.ptr != NULL
-                    ? xmemdupz(obj->via.bin.ptr, obj->via.bin.size)
-                    : NULL;
-    arg->size = obj->via.bin.size;
-    return true;
-  }
-  return false;
-}
-
-bool msgpack_rpc_to_array(const msgpack_object *const obj, Array *const arg)
-  FUNC_ATTR_NONNULL_ALL
-{
-  if (obj->type != MSGPACK_OBJECT_ARRAY) {
-    return false;
-  }
-
-  arg->size = obj->via.array.size;
-  arg->items = xcalloc(obj->via.array.size, sizeof(Object));
-
-  for (uint32_t i = 0; i < obj->via.array.size; i++) {
-    if (!msgpack_rpc_to_object(obj->via.array.ptr + i, &arg->items[i])) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-bool msgpack_rpc_to_dictionary(const msgpack_object *const obj, Dictionary *const arg)
-  FUNC_ATTR_NONNULL_ALL
-{
-  if (obj->type != MSGPACK_OBJECT_MAP) {
-    return false;
-  }
-
-  arg->size = obj->via.array.size;
-  arg->items = xcalloc(obj->via.map.size, sizeof(KeyValuePair));
-
-  for (uint32_t i = 0; i < obj->via.map.size; i++) {
-    if (!msgpack_rpc_to_string(&obj->via.map.ptr[i].key,
-                               &arg->items[i].key)) {
-      return false;
-    }
-
-    if (!msgpack_rpc_to_object(&obj->via.map.ptr[i].val,
-                               &arg->items[i].value)) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
 void msgpack_rpc_from_boolean(Boolean result, msgpack_packer *res)
   FUNC_ATTR_NONNULL_ARG(2)
 {