From 35767912bbe9da4556aab122ba00488c56dd9f17 Mon Sep 17 00:00:00 2001 From: TJ DeVries Date: Tue, 27 Oct 2020 22:20:52 -0400 Subject: api/options: add option metadata --- src/nvim/api/vim.c | 56 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ src/nvim/option.c | 52 ++++++++++++++++++++++++++------------------------ src/nvim/option.h | 21 ++++++++++++++++++++ 3 files changed, 104 insertions(+), 25 deletions(-) (limited to 'src') diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c index 77002697fe..c5dc89410a 100644 --- a/src/nvim/api/vim.c +++ b/src/nvim/api/vim.c @@ -970,6 +970,62 @@ Object nvim_get_option(String name, Error *err) return get_option_from(NULL, SREQ_GLOBAL, name, err); } +Dictionary nvim_get_vimoption_info(Error *err) + FUNC_API_SINCE(7) +{ + Dictionary retval = ARRAY_DICT_INIT; + + vimoption_T *all_options = get_all_vimoptions(); + + int i = 0; + vimoption_T opt; + while (true) { + opt = all_options[i++]; + if (opt.fullname == NULL) { + break; + } + + Dictionary opt_dict = ARRAY_DICT_INIT; + + PUT(opt_dict, "fullname", STRING_OBJ(cstr_to_string(opt.fullname))); + PUT(opt_dict, "shortname", STRING_OBJ(cstr_to_string(opt.shortname))); + PUT(opt_dict, "is_global", BOOLEAN_OBJ(opt.flags & OPT_GLOBAL)); + PUT(opt_dict, "is_local", BOOLEAN_OBJ(opt.flags & OPT_LOCAL)); + PUT(opt_dict, "flag", INTEGER_OBJ(opt.flags)); + PUT(opt_dict, "sourced_sid", INTEGER_OBJ(opt.last_set.script_ctx.sc_sid)); + PUT(opt_dict, "sourced_lnum", INTEGER_OBJ(opt.last_set.script_ctx.sc_lnum)); + PUT(opt_dict, "type", STRING_OBJ(get_option_type_string(opt))); + + PUT(retval, opt.fullname, DICTIONARY_OBJ(opt_dict)); + } + + return retval; +} + +Dictionary nvim_get_option_info(String name, Error *err) + FUNC_API_SINCE(7) +{ + Dictionary retval = ARRAY_DICT_INIT; + + get_option_from(NULL, SREQ_GLOBAL, name, err); + if (ERROR_SET(err)) { + return retval; + } + + int opt_idx = findoption_len((const char *)name.data, name.size); + vimoption_T opt = get_vimoption(opt_idx); + + PUT(retval, "fullname", STRING_OBJ(cstr_to_string(opt.fullname))); + PUT(retval, "shortname", STRING_OBJ(cstr_to_string(opt.shortname))); + PUT(retval, "is_global", BOOLEAN_OBJ(opt.flags & OPT_GLOBAL)); + PUT(retval, "is_local", BOOLEAN_OBJ(opt.flags & OPT_LOCAL)); + PUT(retval, "flag", INTEGER_OBJ(opt.flags)); + PUT(retval, "sourced_sid", INTEGER_OBJ(opt.last_set.script_ctx.sc_sid)); + PUT(retval, "sourced_lnum", INTEGER_OBJ(opt.last_set.script_ctx.sc_lnum)); + + return retval; +} + /// Sets an option value. /// /// @param channel_id diff --git a/src/nvim/option.c b/src/nvim/option.c index 0034117ddc..5e3f917bed 100644 --- a/src/nvim/option.c +++ b/src/nvim/option.c @@ -102,13 +102,6 @@ #define OPT_BUF(x) (idopt_T)(PV_BUF + (int)(x)) #define OPT_BOTH(x) (idopt_T)(PV_BOTH + (int)(x)) - -// WV_ and BV_ values get typecasted to this for the "indir" field -typedef enum { - PV_NONE = 0, - PV_MAXVAL = 0xffff // to avoid warnings for value out of range -} idopt_T; - /* * Options local to a window have a value local to a buffer and global to all * buffers. Indicate this by setting "var" to VAR_WIN. @@ -195,20 +188,6 @@ static long p_sts_nopaste; static long p_tw_nopaste; static long p_wm_nopaste; -typedef struct vimoption { - char *fullname; // full option name - char *shortname; // permissible abbreviation - uint32_t flags; // see below - char_u *var; // global option: pointer to variable; - // window-local option: VAR_WIN; - // buffer-local option: global value - idopt_T indir; // global option: PV_NONE; - // local option: indirect option index - char_u *def_val[2]; // default values for variable (vi and vim) - LastSet last_set; // script in which the option was last set -# define SCTX_INIT , { 0, 0, 0 } -} vimoption_T; - #define VI_DEFAULT 0 // def_val[VI_DEFAULT] is Vi default value #define VIM_DEFAULT 1 // def_val[VIM_DEFAULT] is Vim default value @@ -3617,10 +3596,14 @@ static void set_option_sctx_idx(int opt_idx, int opt_flags, sctx_T script_ctx) { int both = (opt_flags & (OPT_LOCAL | OPT_GLOBAL)) == 0; int indir = (int)options[opt_idx].indir; - const LastSet last_set = { .script_ctx = - { script_ctx.sc_sid, script_ctx.sc_seq, - script_ctx.sc_lnum + sourcing_lnum }, - current_channel_id }; + const LastSet last_set = { + .script_ctx = { + script_ctx.sc_sid, + script_ctx.sc_seq, + script_ctx.sc_lnum + sourcing_lnum + }, + current_channel_id + }; // Remember where the option was set. For local options need to do that // in the buffer or window structure. @@ -7174,3 +7157,22 @@ long get_sidescrolloff_value(void) { return curwin->w_p_siso < 0 ? p_siso : curwin->w_p_siso; } + +vimoption_T get_vimoption(int opt_idx) +{ + return options[opt_idx]; +} + +vimoption_T* get_all_vimoptions(void) +{ + return options; +} + +String get_option_type_string(vimoption_T opt) +{ + return cstr_to_string( + opt.flags & P_BOOL ? "boolean" + : opt.flags & P_NUM ? "number" + : opt.flags & P_STRING ? "string" + : "unknown"); +} diff --git a/src/nvim/option.h b/src/nvim/option.h index 60f14dea44..1bf28e1ce8 100644 --- a/src/nvim/option.h +++ b/src/nvim/option.h @@ -21,6 +21,27 @@ typedef enum { OPT_NOWIN = 32, ///< Don’t set window-local options. } OptionFlags; +// WV_ and BV_ values get typecasted to this for the "indir" field +typedef enum { + PV_NONE = 0, + PV_MAXVAL = 0xffff // to avoid warnings for value out of range +} idopt_T; + +typedef struct vimoption { + char *fullname; // full option name + char *shortname; // permissible abbreviation + uint32_t flags; // see below + char_u *var; // global option: pointer to variable; + // window-local option: VAR_WIN; + // buffer-local option: global value + idopt_T indir; // global option: PV_NONE; + // local option: indirect option index + char_u *def_val[2]; // default values for variable (vi and vim) + LastSet last_set; // script in which the option was last set +# define SCTX_INIT , { 0, 0, 0 } +} vimoption_T; + + #ifdef INCLUDE_GENERATED_DECLARATIONS # include "option.h.generated.h" #endif -- cgit From 3b3c006ae34256637f101ea85a84998377f56e40 Mon Sep 17 00:00:00 2001 From: Björn Linse Date: Tue, 1 Dec 2020 22:10:41 +0100 Subject: api/options: cleanup --- src/nvim/api/vim.c | 50 ++---------------------- src/nvim/option.c | 104 +++++++++++++++++++++++++++++++++++++++++-------- src/nvim/option.h | 21 ---------- src/nvim/option_defs.h | 1 - 4 files changed, 90 insertions(+), 86 deletions(-) (limited to 'src') diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c index c5dc89410a..b3576bc436 100644 --- a/src/nvim/api/vim.c +++ b/src/nvim/api/vim.c @@ -970,60 +970,16 @@ Object nvim_get_option(String name, Error *err) return get_option_from(NULL, SREQ_GLOBAL, name, err); } -Dictionary nvim_get_vimoption_info(Error *err) +Dictionary nvim_get_options_info(Error *err) FUNC_API_SINCE(7) { - Dictionary retval = ARRAY_DICT_INIT; - - vimoption_T *all_options = get_all_vimoptions(); - - int i = 0; - vimoption_T opt; - while (true) { - opt = all_options[i++]; - if (opt.fullname == NULL) { - break; - } - - Dictionary opt_dict = ARRAY_DICT_INIT; - - PUT(opt_dict, "fullname", STRING_OBJ(cstr_to_string(opt.fullname))); - PUT(opt_dict, "shortname", STRING_OBJ(cstr_to_string(opt.shortname))); - PUT(opt_dict, "is_global", BOOLEAN_OBJ(opt.flags & OPT_GLOBAL)); - PUT(opt_dict, "is_local", BOOLEAN_OBJ(opt.flags & OPT_LOCAL)); - PUT(opt_dict, "flag", INTEGER_OBJ(opt.flags)); - PUT(opt_dict, "sourced_sid", INTEGER_OBJ(opt.last_set.script_ctx.sc_sid)); - PUT(opt_dict, "sourced_lnum", INTEGER_OBJ(opt.last_set.script_ctx.sc_lnum)); - PUT(opt_dict, "type", STRING_OBJ(get_option_type_string(opt))); - - PUT(retval, opt.fullname, DICTIONARY_OBJ(opt_dict)); - } - - return retval; + return get_all_vimoptions(); } Dictionary nvim_get_option_info(String name, Error *err) FUNC_API_SINCE(7) { - Dictionary retval = ARRAY_DICT_INIT; - - get_option_from(NULL, SREQ_GLOBAL, name, err); - if (ERROR_SET(err)) { - return retval; - } - - int opt_idx = findoption_len((const char *)name.data, name.size); - vimoption_T opt = get_vimoption(opt_idx); - - PUT(retval, "fullname", STRING_OBJ(cstr_to_string(opt.fullname))); - PUT(retval, "shortname", STRING_OBJ(cstr_to_string(opt.shortname))); - PUT(retval, "is_global", BOOLEAN_OBJ(opt.flags & OPT_GLOBAL)); - PUT(retval, "is_local", BOOLEAN_OBJ(opt.flags & OPT_LOCAL)); - PUT(retval, "flag", INTEGER_OBJ(opt.flags)); - PUT(retval, "sourced_sid", INTEGER_OBJ(opt.last_set.script_ctx.sc_sid)); - PUT(retval, "sourced_lnum", INTEGER_OBJ(opt.last_set.script_ctx.sc_lnum)); - - return retval; + return get_vimoption(name, err); } /// Sets an option value. diff --git a/src/nvim/option.c b/src/nvim/option.c index 5e3f917bed..12468adbe8 100644 --- a/src/nvim/option.c +++ b/src/nvim/option.c @@ -102,6 +102,13 @@ #define OPT_BUF(x) (idopt_T)(PV_BUF + (int)(x)) #define OPT_BOTH(x) (idopt_T)(PV_BOTH + (int)(x)) + +// WV_ and BV_ values get typecasted to this for the "indir" field +typedef enum { + PV_NONE = 0, + PV_MAXVAL = 0xffff // to avoid warnings for value out of range +} idopt_T; + /* * Options local to a window have a value local to a buffer and global to all * buffers. Indicate this by setting "var" to VAR_WIN. @@ -188,6 +195,20 @@ static long p_sts_nopaste; static long p_tw_nopaste; static long p_wm_nopaste; +typedef struct vimoption { + char *fullname; // full option name + char *shortname; // permissible abbreviation + uint32_t flags; // see below + char_u *var; // global option: pointer to variable; + // window-local option: VAR_WIN; + // buffer-local option: global value + idopt_T indir; // global option: PV_NONE; + // local option: indirect option index + char_u *def_val[2]; // default values for variable (vi and vim) + LastSet last_set; // script in which the option was last set +# define SCTX_INIT , { 0, 0, 0 } +} vimoption_T; + #define VI_DEFAULT 0 // def_val[VI_DEFAULT] is Vi default value #define VIM_DEFAULT 1 // def_val[VIM_DEFAULT] is Vim default value @@ -331,9 +352,6 @@ void set_init_1(bool clean_arg) langmap_init(); - // Be nocompatible - p_cp = false; - /* * Find default value for 'shell' option. * Don't use it if it is empty. @@ -662,7 +680,7 @@ set_options_default( { for (int i = 0; options[i].fullname; i++) { if (!(options[i].flags & P_NODEFAULT)) { - set_option_default(i, opt_flags, p_cp); + set_option_default(i, opt_flags, false); } } @@ -742,7 +760,7 @@ void set_init_2(bool headless) // which results in the actual value computed from the window height. idx = findoption("scroll"); if (idx >= 0 && !(options[idx].flags & P_WAS_SET)) { - set_option_default(idx, OPT_LOCAL, p_cp); + set_option_default(idx, OPT_LOCAL, false); } comp_col(); @@ -1092,7 +1110,7 @@ int do_set( if (vim_strchr((char_u *)"?=:!&<", nextchar) != NULL) { arg += len; - cp_val = p_cp; + cp_val = false; if (nextchar == '&' && arg[1] == 'v' && arg[2] == 'i') { if (arg[3] == 'm') { // "opt&vim": set to Vim default cp_val = false; @@ -4933,7 +4951,7 @@ static int optval_default(vimoption_T *p, char_u *varp) if (varp == NULL) { return true; // hidden option is always at default } - dvi = ((p->flags & P_VI_DEF) || p_cp) ? VI_DEFAULT : VIM_DEFAULT; + dvi = (p->flags & P_VI_DEF) ? VI_DEFAULT : VIM_DEFAULT; if (p->flags & P_NUM) { return *(long *)varp == (long)(intptr_t)p->def_val[dvi]; } @@ -7158,21 +7176,73 @@ long get_sidescrolloff_value(void) return curwin->w_p_siso < 0 ? p_siso : curwin->w_p_siso; } -vimoption_T get_vimoption(int opt_idx) +Dictionary get_vimoption(String name, Error *err) { - return options[opt_idx]; + int opt_idx = findoption_len((const char *)name.data, name.size); + if (opt_idx < 0) { + api_set_error(err, kErrorTypeValidation, "no such option %s", name.data); + return (Dictionary)ARRAY_DICT_INIT; + } + return vimoption2dict(&options[opt_idx]); } -vimoption_T* get_all_vimoptions(void) +Dictionary get_all_vimoptions(void) { - return options; + Dictionary retval = ARRAY_DICT_INIT; + for (size_t i = 0; i < PARAM_COUNT; i++) { + Dictionary opt_dict = vimoption2dict(&options[i]); + PUT(retval, options[i].fullname, DICTIONARY_OBJ(opt_dict)); + } + return retval; } -String get_option_type_string(vimoption_T opt) +static Dictionary vimoption2dict(vimoption_T *opt) { - return cstr_to_string( - opt.flags & P_BOOL ? "boolean" - : opt.flags & P_NUM ? "number" - : opt.flags & P_STRING ? "string" - : "unknown"); + Dictionary dict = ARRAY_DICT_INIT; + + PUT(dict, "name", STRING_OBJ(cstr_to_string(opt->fullname))); + PUT(dict, "shortname", STRING_OBJ(cstr_to_string(opt->shortname))); +#define PUT_IF(dict, name, condition) do if (condition) \ + { PUT(dict, name, BOOLEAN_OBJ(true)); } while (0) + PUT_IF(dict, "win", opt->indir & PV_WIN); + PUT_IF(dict, "buf", opt->indir & PV_BUF); + // welcome to the jungle + PUT_IF(dict, "global_local", opt->indir & PV_BOTH); + PUT_IF(dict, "commalist", opt->flags & P_COMMA); + PUT_IF(dict, "flaglist", opt->flags & P_FLAGLIST); + + PUT_IF(dict, "was_set", opt->flags & P_WAS_SET); + + PUT(dict, "flag", INTEGER_OBJ(opt->flags)); // TODO(bfredl): lol tj + PUT(dict, "last_set_sid", INTEGER_OBJ(opt->last_set.script_ctx.sc_sid)); + if (opt->last_set.script_ctx.sc_lnum > 0) { + PUT(dict, "last_set_linenr", + INTEGER_OBJ(opt->last_set.script_ctx.sc_lnum)); + } + if (opt->last_set.channel_id > 0) { + PUT(dict, "last_set_lchan", + INTEGER_OBJ((int64_t)opt->last_set.channel_id)); + } + + const char *type; + Object def; + // TODO(bfredl): do you even nocp? + char_u *def_val = opt->def_val[(opt->flags & P_VI_DEF) + ? VI_DEFAULT : VIM_DEFAULT]; + if (opt->flags & P_STRING) { + type = "string"; + def = STRING_OBJ(cstr_to_string(def_val ? (char *)def_val : "")); + } else if (opt->flags & P_NUM) { + type = "string"; + def = INTEGER_OBJ((Integer)(intptr_t)def_val); + } else if (opt->flags & P_BOOL) { + type = "boolean"; + def = BOOLEAN_OBJ((intptr_t)def_val); + } else { + type = ""; def = NIL; + } + PUT(dict, "type", STRING_OBJ(cstr_to_string(type))); + PUT(dict, "default", def); + + return dict; } diff --git a/src/nvim/option.h b/src/nvim/option.h index 1bf28e1ce8..60f14dea44 100644 --- a/src/nvim/option.h +++ b/src/nvim/option.h @@ -21,27 +21,6 @@ typedef enum { OPT_NOWIN = 32, ///< Don’t set window-local options. } OptionFlags; -// WV_ and BV_ values get typecasted to this for the "indir" field -typedef enum { - PV_NONE = 0, - PV_MAXVAL = 0xffff // to avoid warnings for value out of range -} idopt_T; - -typedef struct vimoption { - char *fullname; // full option name - char *shortname; // permissible abbreviation - uint32_t flags; // see below - char_u *var; // global option: pointer to variable; - // window-local option: VAR_WIN; - // buffer-local option: global value - idopt_T indir; // global option: PV_NONE; - // local option: indirect option index - char_u *def_val[2]; // default values for variable (vi and vim) - LastSet last_set; // script in which the option was last set -# define SCTX_INIT , { 0, 0, 0 } -} vimoption_T; - - #ifdef INCLUDE_GENERATED_DECLARATIONS # include "option.h.generated.h" #endif diff --git a/src/nvim/option_defs.h b/src/nvim/option_defs.h index af0ea7f4a2..ec2160d365 100644 --- a/src/nvim/option_defs.h +++ b/src/nvim/option_defs.h @@ -372,7 +372,6 @@ EXTERN long p_cwh; // 'cmdwinheight' EXTERN long p_ch; // 'cmdheight' EXTERN long p_columns; // 'columns' EXTERN int p_confirm; // 'confirm' -EXTERN int p_cp; // 'compatible' EXTERN char_u *p_cot; // 'completeopt' # ifdef BACKSLASH_IN_FILENAME EXTERN char_u *p_csl; // 'completeslash' -- cgit From ced951c2aacd175c21c68a5bbf7fdf459954d0ab Mon Sep 17 00:00:00 2001 From: TJ DeVries Date: Thu, 3 Dec 2020 20:59:36 -0500 Subject: api/options: fixup --- src/nvim/api/vim.c | 26 ++++++++++++++++++++++++++ src/nvim/option.c | 39 +++++++++++++++++++++------------------ 2 files changed, 47 insertions(+), 18 deletions(-) (limited to 'src') diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c index b3576bc436..a95aa0f170 100644 --- a/src/nvim/api/vim.c +++ b/src/nvim/api/vim.c @@ -970,12 +970,38 @@ Object nvim_get_option(String name, Error *err) return get_option_from(NULL, SREQ_GLOBAL, name, err); } +/// Gets the option information for all options. +/// @return Map Dictionary nvim_get_options_info(Error *err) FUNC_API_SINCE(7) { return get_all_vimoptions(); } +/// Gets the option information for one option +/// +/// Resulting dictionary has keys: +/// - name (string): Name of the option +/// - shortname (shortname): Shortened name of the option +/// - type (string): Name of the type of option +/// - default (Any): The default value for the option +/// +/// Script-Related Keys: +/// - was_set (bool): Whether the option was set. +/// - last_set_sid (int): Last set script id +/// - last_set_linenr (int): Last set script id, -1 if invalid. +/// - last_set_lchan (int): Last set script id, -1 if invalid. +/// +/// Flag-Related Keys: +/// - win (bool): Window-local option +/// - buf (bool): Buffer-local option +/// - global_local (bool): Global or Buffer local option +/// - flaglist (bool): List of single char flags +/// +/// +/// @param name Option name +/// @param[out] err Error details, if any +/// @return Option Information Dictionary nvim_get_option_info(String name, Error *err) FUNC_API_SINCE(7) { diff --git a/src/nvim/option.c b/src/nvim/option.c index 12468adbe8..85f38b02ae 100644 --- a/src/nvim/option.c +++ b/src/nvim/option.c @@ -7180,7 +7180,7 @@ Dictionary get_vimoption(String name, Error *err) { int opt_idx = findoption_len((const char *)name.data, name.size); if (opt_idx < 0) { - api_set_error(err, kErrorTypeValidation, "no such option %s", name.data); + api_set_error(err, kErrorTypeValidation, "no such option: '%s'", name.data); return (Dictionary)ARRAY_DICT_INIT; } return vimoption2dict(&options[opt_idx]); @@ -7202,27 +7202,30 @@ static Dictionary vimoption2dict(vimoption_T *opt) PUT(dict, "name", STRING_OBJ(cstr_to_string(opt->fullname))); PUT(dict, "shortname", STRING_OBJ(cstr_to_string(opt->shortname))); -#define PUT_IF(dict, name, condition) do if (condition) \ - { PUT(dict, name, BOOLEAN_OBJ(true)); } while (0) - PUT_IF(dict, "win", opt->indir & PV_WIN); - PUT_IF(dict, "buf", opt->indir & PV_BUF); + +#define PUT_BOOL(dict, name, condition) \ + PUT(dict, name, BOOLEAN_OBJ(condition)); + + PUT_BOOL(dict, "win", opt->indir & PV_WIN); + PUT_BOOL(dict, "buf", opt->indir & PV_BUF); + // welcome to the jungle - PUT_IF(dict, "global_local", opt->indir & PV_BOTH); - PUT_IF(dict, "commalist", opt->flags & P_COMMA); - PUT_IF(dict, "flaglist", opt->flags & P_FLAGLIST); + PUT_BOOL(dict, "global_local", opt->indir & PV_BOTH); + PUT_BOOL(dict, "commalist", opt->flags & P_COMMA); + PUT_BOOL(dict, "flaglist", opt->flags & P_FLAGLIST); - PUT_IF(dict, "was_set", opt->flags & P_WAS_SET); + PUT_BOOL(dict, "was_set", opt->flags & P_WAS_SET); +#undef PUT_BOOL - PUT(dict, "flag", INTEGER_OBJ(opt->flags)); // TODO(bfredl): lol tj PUT(dict, "last_set_sid", INTEGER_OBJ(opt->last_set.script_ctx.sc_sid)); - if (opt->last_set.script_ctx.sc_lnum > 0) { - PUT(dict, "last_set_linenr", - INTEGER_OBJ(opt->last_set.script_ctx.sc_lnum)); - } - if (opt->last_set.channel_id > 0) { - PUT(dict, "last_set_lchan", - INTEGER_OBJ((int64_t)opt->last_set.channel_id)); - } + PUT(dict, "last_set_linenr", + opt->last_set.script_ctx.sc_lnum > 0 + ? INTEGER_OBJ(opt->last_set.script_ctx.sc_lnum) + : INTEGER_OBJ(-1)); + PUT(dict, "last_set_lchan", + opt->last_set.channel_id > 0 + ? INTEGER_OBJ((int64_t)opt->last_set.channel_id) + : INTEGER_OBJ(-1)); const char *type; Object def; -- cgit From 17a58043a3fc49179a47590e905ed3a7d5a29907 Mon Sep 17 00:00:00 2001 From: Björn Linse Date: Fri, 4 Dec 2020 10:59:58 +0100 Subject: api/options: cleanup the fixup --- src/nvim/api/private/helpers.h | 5 +++++ src/nvim/api/vim.c | 39 ++++++++++++++++++----------------- src/nvim/option.c | 46 ++++++++++++++++++++---------------------- 3 files changed, 48 insertions(+), 42 deletions(-) (limited to 'src') diff --git a/src/nvim/api/private/helpers.h b/src/nvim/api/private/helpers.h index 271fd5b485..055abb797f 100644 --- a/src/nvim/api/private/helpers.h +++ b/src/nvim/api/private/helpers.h @@ -16,6 +16,7 @@ #define BOOLEAN_OBJ(b) ((Object) { \ .type = kObjectTypeBoolean, \ .data.boolean = b }) +#define BOOL(b) BOOLEAN_OBJ(b) #define INTEGER_OBJ(i) ((Object) { \ .type = kObjectTypeInteger, \ @@ -29,6 +30,8 @@ .type = kObjectTypeString, \ .data.string = s }) +#define CSTR_TO_OBJ(s) STRING_OBJ(cstr_to_string(s)) + #define BUFFER_OBJ(s) ((Object) { \ .type = kObjectTypeBuffer, \ .data.integer = s }) @@ -59,6 +62,8 @@ #define PUT(dict, k, v) \ kv_push(dict, ((KeyValuePair) { .key = cstr_to_string(k), .value = v })) +#define PUT_BOOL(dict, name, condition) PUT(dict, name, BOOLEAN_OBJ(condition)); + #define ADD(array, item) \ kv_push(array, item) diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c index a95aa0f170..8ac820abd9 100644 --- a/src/nvim/api/vim.c +++ b/src/nvim/api/vim.c @@ -971,8 +971,12 @@ Object nvim_get_option(String name, Error *err) } /// Gets the option information for all options. -/// @return Map -Dictionary nvim_get_options_info(Error *err) +/// +/// The dictionary has the full option names as keys and option metadata +/// dictionaries as detailed at |nvim_get_option_info|. +/// +/// @return dictionary of all options +Dictionary nvim_get_all_options_info(Error *err) FUNC_API_SINCE(7) { return get_all_vimoptions(); @@ -981,22 +985,21 @@ Dictionary nvim_get_options_info(Error *err) /// Gets the option information for one option /// /// Resulting dictionary has keys: -/// - name (string): Name of the option -/// - shortname (shortname): Shortened name of the option -/// - type (string): Name of the type of option -/// - default (Any): The default value for the option -/// -/// Script-Related Keys: -/// - was_set (bool): Whether the option was set. -/// - last_set_sid (int): Last set script id -/// - last_set_linenr (int): Last set script id, -1 if invalid. -/// - last_set_lchan (int): Last set script id, -1 if invalid. -/// -/// Flag-Related Keys: -/// - win (bool): Window-local option -/// - buf (bool): Buffer-local option -/// - global_local (bool): Global or Buffer local option -/// - flaglist (bool): List of single char flags +/// - name: Name of the option (like 'filetype') +/// - shortname: Shortened name of the option (like 'ft') +/// - type: type of option ("string", "integer" or "boolean") +/// - default: The default value for the option +/// - was_set: Whether the option was set. +/// +/// - last_set_sid: Last set script id (if any) +/// - last_set_linenr: line number where option was set +/// - last_set_chan: Channel where option was set (0 for local) +/// +/// - scope: one of "global", "win", or "buf" +/// - global_local: whether win or buf option has a global value +/// +/// - commalist: List of comma separated values +/// - flaglist: List of single char flags /// /// /// @param name Option name diff --git a/src/nvim/option.c b/src/nvim/option.c index 85f38b02ae..acca6fe681 100644 --- a/src/nvim/option.c +++ b/src/nvim/option.c @@ -7200,32 +7200,30 @@ static Dictionary vimoption2dict(vimoption_T *opt) { Dictionary dict = ARRAY_DICT_INIT; - PUT(dict, "name", STRING_OBJ(cstr_to_string(opt->fullname))); - PUT(dict, "shortname", STRING_OBJ(cstr_to_string(opt->shortname))); - -#define PUT_BOOL(dict, name, condition) \ - PUT(dict, name, BOOLEAN_OBJ(condition)); + PUT(dict, "name", CSTR_TO_OBJ(opt->fullname)); + PUT(dict, "shortname", CSTR_TO_OBJ(opt->shortname)); + + const char *scope; + if (opt->indir & PV_BUF) { + scope = "buf"; + } else if (opt->indir & PV_WIN) { + scope = "win"; + } else { + scope = "global"; + } - PUT_BOOL(dict, "win", opt->indir & PV_WIN); - PUT_BOOL(dict, "buf", opt->indir & PV_BUF); + PUT(dict, "scope", CSTR_TO_OBJ(scope)); // welcome to the jungle - PUT_BOOL(dict, "global_local", opt->indir & PV_BOTH); - PUT_BOOL(dict, "commalist", opt->flags & P_COMMA); - PUT_BOOL(dict, "flaglist", opt->flags & P_FLAGLIST); + PUT(dict, "global_local", BOOL(opt->indir & PV_BOTH)); + PUT(dict, "commalist", BOOL(opt->flags & P_COMMA)); + PUT(dict, "flaglist", BOOL(opt->flags & P_FLAGLIST)); - PUT_BOOL(dict, "was_set", opt->flags & P_WAS_SET); -#undef PUT_BOOL + PUT(dict, "was_set", BOOL(opt->flags & P_WAS_SET)); PUT(dict, "last_set_sid", INTEGER_OBJ(opt->last_set.script_ctx.sc_sid)); - PUT(dict, "last_set_linenr", - opt->last_set.script_ctx.sc_lnum > 0 - ? INTEGER_OBJ(opt->last_set.script_ctx.sc_lnum) - : INTEGER_OBJ(-1)); - PUT(dict, "last_set_lchan", - opt->last_set.channel_id > 0 - ? INTEGER_OBJ((int64_t)opt->last_set.channel_id) - : INTEGER_OBJ(-1)); + PUT(dict, "last_set_linenr", INTEGER_OBJ(opt->last_set.script_ctx.sc_lnum)); + PUT(dict, "last_set_chan", INTEGER_OBJ((int64_t)opt->last_set.channel_id)); const char *type; Object def; @@ -7234,17 +7232,17 @@ static Dictionary vimoption2dict(vimoption_T *opt) ? VI_DEFAULT : VIM_DEFAULT]; if (opt->flags & P_STRING) { type = "string"; - def = STRING_OBJ(cstr_to_string(def_val ? (char *)def_val : "")); + def = CSTR_TO_OBJ(def_val ? (char *)def_val : ""); } else if (opt->flags & P_NUM) { - type = "string"; + type = "number"; def = INTEGER_OBJ((Integer)(intptr_t)def_val); } else if (opt->flags & P_BOOL) { type = "boolean"; - def = BOOLEAN_OBJ((intptr_t)def_val); + def = BOOL((intptr_t)def_val); } else { type = ""; def = NIL; } - PUT(dict, "type", STRING_OBJ(cstr_to_string(type))); + PUT(dict, "type", CSTR_TO_OBJ(type)); PUT(dict, "default", def); return dict; -- cgit