1 files changed, 287 insertions, 156 deletions

diff --git a/src/nvim/api/private/helpers.c b/src/nvim/api/private/helpers.c
index db3e499427..7daa4d7207 100644
--- a/src/nvim/api/private/helpers.c
+++ b/src/nvim/api/private/helpers.c
@@ -7,6 +7,7 @@
 #include "nvim/api/private/helpers.h"
 #include "nvim/api/private/defs.h"
 #include "nvim/api/private/handle.h"
+#include "nvim/msgpack_rpc/helpers.h"
 #include "nvim/ascii.h"
 #include "nvim/vim.h"
 #include "nvim/buffer.h"
@@ -17,9 +18,17 @@
 #include "nvim/map.h"
 #include "nvim/option.h"
 #include "nvim/option_defs.h"
+#include "nvim/version.h"
+#include "nvim/lib/kvec.h"
+
+/// Helper structure for vim_to_object
+typedef struct {
+  kvec_t(Object) stack;  ///< Object stack.
+} EncodedData;
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "api/private/helpers.c.generated.h"
+# include "api/private/funcs_metadata.generated.h"
 #endif
 
 /// Start block that may cause vimscript exceptions
@@ -97,10 +106,11 @@ Object dict_get_value(dict_T *dict, String key, Error *err)
 /// @param value The new value
 /// @param del Delete key in place of setting it. Argument `value` is ignored in
 ///            this case.
+/// @param retval If true the old value will be converted and returned.
 /// @param[out] err Details of an error that may have occurred
-/// @return the old value, if any
+/// @return The old value if `retval` is true and the key was present, else NIL
 Object dict_set_value(dict_T *dict, String key, Object value, bool del,
-                      Error *err)
+                      bool retval, Error *err)
 {
   Object rv = OBJECT_INIT;
 
@@ -128,7 +138,9 @@ Object dict_set_value(dict_T *dict, String key, Object value, bool del,
       api_set_error(err, Validation, _("Key \"%s\" doesn't exist"), key.data);
     } else {
       // Return the old value
-      rv = vim_to_object(&di->di_tv);
+      if (retval) {
+        rv = vim_to_object(&di->di_tv);
+      }
       // Delete the entry
       hashitem_T *hi = hash_find(&dict->dv_hashtab, di->di_key);
       hash_remove(&dict->dv_hashtab, hi);
@@ -149,7 +161,9 @@ Object dict_set_value(dict_T *dict, String key, Object value, bool del,
       dict_add(dict, di);
     } else {
       // Return the old value
-      rv = vim_to_object(&di->di_tv);
+      if (retval) {
+        rv = vim_to_object(&di->di_tv);
+      }
       clear_tv(&di->di_tv);
     }
 
@@ -310,6 +324,201 @@ void set_option_to(void *to, int type, String name, Object value, Error *err)
   }
 }
 
+#define TYPVAL_ENCODE_ALLOW_SPECIALS false
+
+#define TYPVAL_ENCODE_CONV_NIL(tv) \
+    kv_push(edata->stack, NIL)
+
+#define TYPVAL_ENCODE_CONV_BOOL(tv, num) \
+    kv_push(edata->stack, BOOLEAN_OBJ((Boolean)(num)))
+
+#define TYPVAL_ENCODE_CONV_NUMBER(tv, num) \
+    kv_push(edata->stack, INTEGER_OBJ((Integer)(num)))
+
+#define TYPVAL_ENCODE_CONV_UNSIGNED_NUMBER TYPVAL_ENCODE_CONV_NUMBER
+
+#define TYPVAL_ENCODE_CONV_FLOAT(tv, flt) \
+    kv_push(edata->stack, FLOATING_OBJ((Float)(flt)))
+
+#define TYPVAL_ENCODE_CONV_STRING(tv, str, len) \
+    do { \
+      const size_t len_ = (size_t)(len); \
+      const char *const str_ = (const char *)(str); \
+      assert(len_ == 0 || str_ != NULL); \
+      kv_push(edata->stack, STRING_OBJ(((String) { \
+        .data = xmemdupz((len_?str_:""), len_), \
+        .size = len_ \
+      }))); \
+    } while (0)
+
+#define TYPVAL_ENCODE_CONV_STR_STRING TYPVAL_ENCODE_CONV_STRING
+
+#define TYPVAL_ENCODE_CONV_EXT_STRING(tv, str, len, type) \
+    TYPVAL_ENCODE_CONV_NIL(tv)
+
+#define TYPVAL_ENCODE_CONV_FUNC_START(tv, fun) \
+    do { \
+      TYPVAL_ENCODE_CONV_NIL(tv); \
+      goto typval_encode_stop_converting_one_item; \
+    } while (0)
+
+#define TYPVAL_ENCODE_CONV_FUNC_BEFORE_ARGS(tv, len)
+#define TYPVAL_ENCODE_CONV_FUNC_BEFORE_SELF(tv, len)
+#define TYPVAL_ENCODE_CONV_FUNC_END(tv)
+
+#define TYPVAL_ENCODE_CONV_EMPTY_LIST(tv) \
+    kv_push(edata->stack, ARRAY_OBJ(((Array) { .capacity = 0, .size = 0 })))
+
+#define TYPVAL_ENCODE_CONV_EMPTY_DICT(tv, dict) \
+    kv_push(edata->stack, \
+            DICTIONARY_OBJ(((Dictionary) { .capacity = 0, .size = 0 })))
+
+static inline void typval_encode_list_start(EncodedData *const edata,
+                                            const size_t len)
+  FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_NONNULL_ALL
+{
+  kv_push(edata->stack, ARRAY_OBJ(((Array) {
+    .capacity = len,
+    .size = 0,
+    .items = xmalloc(len * sizeof(*((Object *)NULL)->data.array.items)),
+  })));
+}
+
+#define TYPVAL_ENCODE_CONV_LIST_START(tv, len) \
+    typval_encode_list_start(edata, (size_t)(len))
+
+#define TYPVAL_ENCODE_CONV_REAL_LIST_AFTER_START(tv, mpsv)
+
+static inline void typval_encode_between_list_items(EncodedData *const edata)
+  FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_NONNULL_ALL
+{
+  Object item = kv_pop(edata->stack);
+  Object *const list = &kv_last(edata->stack);
+  assert(list->type == kObjectTypeArray);
+  assert(list->data.array.size < list->data.array.capacity);
+  list->data.array.items[list->data.array.size++] = item;
+}
+
+#define TYPVAL_ENCODE_CONV_LIST_BETWEEN_ITEMS(tv) \
+    typval_encode_between_list_items(edata)
+
+static inline void typval_encode_list_end(EncodedData *const edata)
+  FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_NONNULL_ALL
+{
+  typval_encode_between_list_items(edata);
+#ifndef NDEBUG
+  const Object *const list = &kv_last(edata->stack);
+  assert(list->data.array.size == list->data.array.capacity);
+#endif
+}
+
+#define TYPVAL_ENCODE_CONV_LIST_END(tv) \
+    typval_encode_list_end(edata)
+
+static inline void typval_encode_dict_start(EncodedData *const edata,
+                                            const size_t len)
+  FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_NONNULL_ALL
+{
+  kv_push(edata->stack, DICTIONARY_OBJ(((Dictionary) {
+    .capacity = len,
+    .size = 0,
+    .items = xmalloc(len * sizeof(*((Object *)NULL)->data.dictionary.items)),
+  })));
+}
+
+#define TYPVAL_ENCODE_CONV_DICT_START(tv, dict, len) \
+    typval_encode_dict_start(edata, (size_t)(len))
+
+#define TYPVAL_ENCODE_CONV_REAL_DICT_AFTER_START(tv, dict, mpsv)
+
+#define TYPVAL_ENCODE_SPECIAL_DICT_KEY_CHECK(label, kv_pair)
+
+static inline void typval_encode_after_key(EncodedData *const edata)
+  FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_NONNULL_ALL
+{
+  Object key = kv_pop(edata->stack);
+  Object *const dict = &kv_last(edata->stack);
+  assert(dict->type == kObjectTypeDictionary);
+  assert(dict->data.dictionary.size < dict->data.dictionary.capacity);
+  if (key.type == kObjectTypeString) {
+    dict->data.dictionary.items[dict->data.dictionary.size].key
+        = key.data.string;
+  } else {
+    api_free_object(key);
+    dict->data.dictionary.items[dict->data.dictionary.size].key
+        = STATIC_CSTR_TO_STRING("__INVALID_KEY__");
+  }
+}
+
+#define TYPVAL_ENCODE_CONV_DICT_AFTER_KEY(tv, dict) \
+    typval_encode_after_key(edata)
+
+static inline void typval_encode_between_dict_items(EncodedData *const edata)
+  FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_NONNULL_ALL
+{
+  Object val = kv_pop(edata->stack);
+  Object *const dict = &kv_last(edata->stack);
+  assert(dict->type == kObjectTypeDictionary);
+  assert(dict->data.dictionary.size < dict->data.dictionary.capacity);
+  dict->data.dictionary.items[dict->data.dictionary.size++].value = val;
+}
+
+#define TYPVAL_ENCODE_CONV_DICT_BETWEEN_ITEMS(tv, dict) \
+    typval_encode_between_dict_items(edata)
+
+static inline void typval_encode_dict_end(EncodedData *const edata)
+  FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_NONNULL_ALL
+{
+  typval_encode_between_dict_items(edata);
+#ifndef NDEBUG
+  const Object *const dict = &kv_last(edata->stack);
+  assert(dict->data.dictionary.size == dict->data.dictionary.capacity);
+#endif
+}
+
+#define TYPVAL_ENCODE_CONV_DICT_END(tv, dict) \
+    typval_encode_dict_end(edata)
+
+#define TYPVAL_ENCODE_CONV_RECURSE(val, conv_type) \
+    TYPVAL_ENCODE_CONV_NIL()
+
+#define TYPVAL_ENCODE_SCOPE static
+#define TYPVAL_ENCODE_NAME object
+#define TYPVAL_ENCODE_FIRST_ARG_TYPE EncodedData *const
+#define TYPVAL_ENCODE_FIRST_ARG_NAME edata
+#include "nvim/eval/typval_encode.c.h"
+#undef TYPVAL_ENCODE_SCOPE
+#undef TYPVAL_ENCODE_NAME
+#undef TYPVAL_ENCODE_FIRST_ARG_TYPE
+#undef TYPVAL_ENCODE_FIRST_ARG_NAME
+
+#undef TYPVAL_ENCODE_CONV_STRING
+#undef TYPVAL_ENCODE_CONV_STR_STRING
+#undef TYPVAL_ENCODE_CONV_EXT_STRING
+#undef TYPVAL_ENCODE_CONV_NUMBER
+#undef TYPVAL_ENCODE_CONV_FLOAT
+#undef TYPVAL_ENCODE_CONV_FUNC_START
+#undef TYPVAL_ENCODE_CONV_FUNC_BEFORE_ARGS
+#undef TYPVAL_ENCODE_CONV_FUNC_BEFORE_SELF
+#undef TYPVAL_ENCODE_CONV_FUNC_END
+#undef TYPVAL_ENCODE_CONV_EMPTY_LIST
+#undef TYPVAL_ENCODE_CONV_LIST_START
+#undef TYPVAL_ENCODE_CONV_REAL_LIST_AFTER_START
+#undef TYPVAL_ENCODE_CONV_EMPTY_DICT
+#undef TYPVAL_ENCODE_CONV_NIL
+#undef TYPVAL_ENCODE_CONV_BOOL
+#undef TYPVAL_ENCODE_CONV_UNSIGNED_NUMBER
+#undef TYPVAL_ENCODE_CONV_DICT_START
+#undef TYPVAL_ENCODE_CONV_REAL_DICT_AFTER_START
+#undef TYPVAL_ENCODE_CONV_DICT_END
+#undef TYPVAL_ENCODE_CONV_DICT_AFTER_KEY
+#undef TYPVAL_ENCODE_CONV_DICT_BETWEEN_ITEMS
+#undef TYPVAL_ENCODE_SPECIAL_DICT_KEY_CHECK
+#undef TYPVAL_ENCODE_CONV_LIST_END
+#undef TYPVAL_ENCODE_CONV_LIST_BETWEEN_ITEMS
+#undef TYPVAL_ENCODE_CONV_RECURSE
+#undef TYPVAL_ENCODE_ALLOW_SPECIALS
+
 /// Convert a vim object to an `Object` instance, recursively expanding
 /// Arrays/Dictionaries.
 ///
@@ -317,17 +526,23 @@ void set_option_to(void *to, int type, String name, Object value, Error *err)
 /// @return The converted value
 Object vim_to_object(typval_T *obj)
 {
-  Object rv;
-  // We use a lookup table to break out of cyclic references
-  PMap(ptr_t) *lookup = pmap_new(ptr_t)();
-  rv = vim_to_object_rec(obj, lookup);
-  // Free the table
-  pmap_free(ptr_t)(lookup);
-  return rv;
+  EncodedData edata = { .stack = KV_INITIAL_VALUE };
+  const int evo_ret = encode_vim_to_object(&edata, obj,
+                                           "vim_to_object argument");
+  (void)evo_ret;
+  assert(evo_ret == OK);
+  Object ret = kv_A(edata.stack, 0);
+  assert(kv_size(edata.stack) == 1);
+  kv_destroy(edata.stack);
+  return ret;
 }
 
 buf_T *find_buffer_by_handle(Buffer buffer, Error *err)
 {
+  if (buffer == 0) {
+    return curbuf;
+  }
+
   buf_T *rv = handle_get_buffer(buffer);
 
   if (!rv) {
@@ -339,6 +554,10 @@ buf_T *find_buffer_by_handle(Buffer buffer, Error *err)
 
 win_T * find_window_by_handle(Window window, Error *err)
 {
+  if (window == 0) {
+    return curwin;
+  }
+
   win_T *rv = handle_get_window(window);
 
   if (!rv) {
@@ -350,6 +569,10 @@ win_T * find_window_by_handle(Window window, Error *err)
 
 tabpage_T * find_tab_by_handle(Tabpage tabpage, Error *err)
 {
+  if (tabpage == 0) {
+    return curtab;
+  }
+
   tabpage_T *rv = handle_get_tabpage(tabpage);
 
   if (!rv) {
@@ -393,10 +616,16 @@ String cstr_as_string(char *str) FUNC_ATTR_PURE
   return (String) {.data = str, .size = strlen(str)};
 }
 
+/// Converts from type Object to a VimL value.
+///
+/// @param obj  Object to convert from.
+/// @param tv   Conversion result is placed here. On failure member v_type is
+///             set to VAR_UNKNOWN (no allocation was made for this variable).
+/// returns     true if conversion is successful, otherwise false.
 bool object_to_vim(Object obj, typval_T *tv, Error *err)
 {
   tv->v_type = VAR_UNKNOWN;
-  tv->v_lock = 0;
+  tv->v_lock = VAR_UNLOCKED;
 
   switch (obj.type) {
     case kObjectTypeNil:
@@ -413,13 +642,14 @@ bool object_to_vim(Object obj, typval_T *tv, Error *err)
     case kObjectTypeWindow:
     case kObjectTypeTabpage:
     case kObjectTypeInteger:
-      if (obj.data.integer > INT_MAX || obj.data.integer < INT_MIN) {
+      if (obj.data.integer > VARNUMBER_MAX
+          || obj.data.integer < VARNUMBER_MIN) {
         api_set_error(err, Validation, _("Integer value outside range"));
         return false;
       }
 
       tv->v_type = VAR_NUMBER;
-      tv->vval.v_number = (int)obj.data.integer;
+      tv->vval.v_number = (varnumber_T)obj.data.integer;
       break;
 
     case kObjectTypeFloat:
@@ -437,9 +667,8 @@ bool object_to_vim(Object obj, typval_T *tv, Error *err)
       }
       break;
 
-    case kObjectTypeArray:
-      tv->v_type = VAR_LIST;
-      tv->vval.v_list = list_alloc();
+    case kObjectTypeArray: {
+      list_T *list = list_alloc();
 
       for (uint32_t i = 0; i < obj.data.array.size; i++) {
         Object item = obj.data.array.items[i];
@@ -448,45 +677,51 @@ bool object_to_vim(Object obj, typval_T *tv, Error *err)
         if (!object_to_vim(item, &li->li_tv, err)) {
           // cleanup
           listitem_free(li);
-          list_free(tv->vval.v_list, true);
+          list_free(list);
           return false;
         }
 
-        list_append(tv->vval.v_list, li);
+        list_append(list, li);
       }
-      tv->vval.v_list->lv_refcount++;
+      list->lv_refcount++;
+
+      tv->v_type = VAR_LIST;
+      tv->vval.v_list = list;
       break;
+    }
 
-    case kObjectTypeDictionary:
-      tv->v_type = VAR_DICT;
-      tv->vval.v_dict = dict_alloc();
+    case kObjectTypeDictionary: {
+      dict_T *dict = dict_alloc();
 
       for (uint32_t i = 0; i < obj.data.dictionary.size; i++) {
         KeyValuePair item = obj.data.dictionary.items[i];
         String key = item.key;
 
         if (key.size == 0) {
-          api_set_error(err,
-                        Validation,
+          api_set_error(err, Validation,
                         _("Empty dictionary keys aren't allowed"));
           // cleanup
-          dict_free(tv->vval.v_dict, true);
+          dict_free(dict);
           return false;
         }
 
-        dictitem_T *di = dictitem_alloc((uint8_t *) key.data);
+        dictitem_T *di = dictitem_alloc((uint8_t *)key.data);
 
         if (!object_to_vim(item.value, &di->di_tv, err)) {
           // cleanup
           dictitem_free(di);
-          dict_free(tv->vval.v_dict, true);
+          dict_free(dict);
           return false;
         }
 
-        dict_add(tv->vval.v_dict, di);
+        dict_add(dict, di);
       }
-      tv->vval.v_dict->dv_refcount++;
+      dict->dv_refcount++;
+
+      tv->v_type = VAR_DICT;
+      tv->vval.v_dict = dict;
       break;
+    }
     default:
       abort();
   }
@@ -556,7 +791,8 @@ Dictionary api_metadata(void)
   static Dictionary metadata = ARRAY_DICT_INIT;
 
   if (!metadata.size) {
-    msgpack_rpc_init_function_metadata(&metadata);
+    PUT(metadata, "version", DICTIONARY_OBJ(version_dict()));
+    init_function_metadata(&metadata);
     init_error_type_metadata(&metadata);
     init_type_metadata(&metadata);
   }
@@ -564,6 +800,22 @@ Dictionary api_metadata(void)
   return copy_object(DICTIONARY_OBJ(metadata)).data.dictionary;
 }
 
+static void init_function_metadata(Dictionary *metadata)
+{
+  msgpack_unpacked unpacked;
+  msgpack_unpacked_init(&unpacked);
+  if (msgpack_unpack_next(&unpacked,
+                          (const char *)funcs_metadata,
+                          sizeof(funcs_metadata),
+                          NULL) != MSGPACK_UNPACK_SUCCESS) {
+    abort();
+  }
+  Object functions;
+  msgpack_rpc_to_object(&unpacked.data, &functions);
+  msgpack_unpacked_destroy(&unpacked);
+  PUT(*metadata, "functions", functions);
+}
+
 static void init_error_type_metadata(Dictionary *metadata)
 {
   Dictionary types = ARRAY_DICT_INIT;
@@ -579,18 +831,22 @@ static void init_error_type_metadata(Dictionary *metadata)
 
   PUT(*metadata, "error_types", DICTIONARY_OBJ(types));
 }
+
 static void init_type_metadata(Dictionary *metadata)
 {
   Dictionary types = ARRAY_DICT_INIT;
 
   Dictionary buffer_metadata = ARRAY_DICT_INIT;
   PUT(buffer_metadata, "id", INTEGER_OBJ(kObjectTypeBuffer));
+  PUT(buffer_metadata, "prefix", STRING_OBJ(cstr_to_string("nvim_buf_")));
 
   Dictionary window_metadata = ARRAY_DICT_INIT;
   PUT(window_metadata, "id", INTEGER_OBJ(kObjectTypeWindow));
+  PUT(window_metadata, "prefix", STRING_OBJ(cstr_to_string("nvim_win_")));
 
   Dictionary tabpage_metadata = ARRAY_DICT_INIT;
   PUT(tabpage_metadata, "id", INTEGER_OBJ(kObjectTypeTabpage));
+  PUT(tabpage_metadata, "prefix", STRING_OBJ(cstr_to_string("nvim_tabpage_")));
 
   PUT(types, "Buffer", DICTIONARY_OBJ(buffer_metadata));
   PUT(types, "Window", DICTIONARY_OBJ(window_metadata));
@@ -633,131 +889,6 @@ Object copy_object(Object obj)
   }
 }
 
-/// Recursion helper for the `vim_to_object`. This uses a pointer table
-/// to avoid infinite recursion due to cyclic references
-///
-/// @param obj The source object
-/// @param lookup Lookup table containing pointers to all processed objects
-/// @return The converted value
-static Object vim_to_object_rec(typval_T *obj, PMap(ptr_t) *lookup)
-{
-  Object rv = OBJECT_INIT;
-
-  if (obj->v_type == VAR_LIST || obj->v_type == VAR_DICT) {
-    // Container object, add it to the lookup table
-    if (pmap_has(ptr_t)(lookup, obj)) {
-      // It's already present, meaning we alredy processed it so just return
-      // nil instead.
-      return rv;
-    }
-    pmap_put(ptr_t)(lookup, obj, NULL);
-  }
-
-  switch (obj->v_type) {
-    case VAR_SPECIAL:
-      switch (obj->vval.v_special) {
-        case kSpecialVarTrue:
-        case kSpecialVarFalse: {
-          rv.type = kObjectTypeBoolean;
-          rv.data.boolean = (obj->vval.v_special == kSpecialVarTrue);
-          break;
-        }
-        case kSpecialVarNull: {
-          rv.type = kObjectTypeNil;
-          break;
-        }
-      }
-      break;
-
-    case VAR_STRING:
-      rv.type = kObjectTypeString;
-      rv.data.string = cstr_to_string((char *) obj->vval.v_string);
-      break;
-
-    case VAR_NUMBER:
-      rv.type = kObjectTypeInteger;
-      rv.data.integer = obj->vval.v_number;
-      break;
-
-    case VAR_FLOAT:
-      rv.type = kObjectTypeFloat;
-      rv.data.floating = obj->vval.v_float;
-      break;
-
-    case VAR_LIST:
-      {
-        list_T *list = obj->vval.v_list;
-        listitem_T *item;
-
-        if (list != NULL) {
-          rv.type = kObjectTypeArray;
-          assert(list->lv_len >= 0);
-          rv.data.array.size = (size_t)list->lv_len;
-          rv.data.array.items = xmalloc(rv.data.array.size * sizeof(Object));
-
-          uint32_t i = 0;
-          for (item = list->lv_first; item != NULL; item = item->li_next) {
-            rv.data.array.items[i] = vim_to_object_rec(&item->li_tv, lookup);
-            i++;
-          }
-        }
-      }
-      break;
-
-    case VAR_DICT:
-      {
-        dict_T *dict = obj->vval.v_dict;
-        hashtab_T *ht;
-        uint64_t todo;
-        hashitem_T *hi;
-        dictitem_T *di;
-
-        if (dict != NULL) {
-          ht = &obj->vval.v_dict->dv_hashtab;
-          todo = ht->ht_used;
-          rv.type = kObjectTypeDictionary;
-
-          // Count items
-          rv.data.dictionary.size = 0;
-          for (hi = ht->ht_array; todo > 0; ++hi) {
-            if (!HASHITEM_EMPTY(hi)) {
-              todo--;
-              rv.data.dictionary.size++;
-            }
-          }
-
-          rv.data.dictionary.items =
-            xmalloc(rv.data.dictionary.size * sizeof(KeyValuePair));
-          todo = ht->ht_used;
-          uint32_t i = 0;
-
-          // Convert all
-          for (hi = ht->ht_array; todo > 0; ++hi) {
-            if (!HASHITEM_EMPTY(hi)) {
-              di = dict_lookup(hi);
-              // Convert key
-              rv.data.dictionary.items[i].key =
-                cstr_to_string((char *) hi->hi_key);
-              // Convert value
-              rv.data.dictionary.items[i].value =
-                vim_to_object_rec(&di->di_tv, lookup);
-              todo--;
-              i++;
-            }
-          }
-        }
-      }
-      break;
-
-    case VAR_UNKNOWN:
-    case VAR_FUNC:
-      break;
-  }
-
-  return rv;
-}
-
-
 static void set_option_value_for(char *key,
                                  int numval,
                                  char *stringval,