patch 8.1.1957: more code can be moved to evalvars.c

Problem:    More code can be moved to evalvars.c.
Solution:   Move code to where it fits better. (Yegappan Lakshmanan,
            closes #4883)

Author: brammool

src/eval.c

@@ -4317,3 +4317,111 @@ script_get(exarg_T *eap, char_u *cmd)
 
     return (char_u *)ga.ga_data;
 }
+
+#if defined(FEAT_EVAL) || defined(PROTO)
+/*
+ * This function is used by f_input() and f_inputdialog() functions. The third
+ * argument to f_input() specifies the type of completion to use at the
+ * prompt. The third argument to f_inputdialog() specifies the value to return
+ * when the user cancels the prompt.
+ */
+    void
+get_user_input(
+    typval_T	*argvars,
+    typval_T	*rettv,
+    int		inputdialog,
+    int		secret)
+{
+    char_u	*prompt = tv_get_string_chk(&argvars[0]);
+    char_u	*p = NULL;
+    int		c;
+    char_u	buf[NUMBUFLEN];
+    int		cmd_silent_save = cmd_silent;
+    char_u	*defstr = (char_u *)"";
+    int		xp_type = EXPAND_NOTHING;
+    char_u	*xp_arg = NULL;
+
+    rettv->v_type = VAR_STRING;
+    rettv->vval.v_string = NULL;
+
+#ifdef NO_CONSOLE_INPUT
+    // While starting up, there is no place to enter text. When running tests
+    // with --not-a-term we assume feedkeys() will be used.
+    if (no_console_input() && !is_not_a_term())
+	return;
+#endif
+
+    cmd_silent = FALSE;		// Want to see the prompt.
+    if (prompt != NULL)
+    {
+	// Only the part of the message after the last NL is considered as
+	// prompt for the command line
+	p = vim_strrchr(prompt, '\n');
+	if (p == NULL)
+	    p = prompt;
+	else
+	{
+	    ++p;
+	    c = *p;
+	    *p = NUL;
+	    msg_start();
+	    msg_clr_eos();
+	    msg_puts_attr((char *)prompt, get_echo_attr());
+	    msg_didout = FALSE;
+	    msg_starthere();
+	    *p = c;
+	}
+	cmdline_row = msg_row;
+
+	if (argvars[1].v_type != VAR_UNKNOWN)
+	{
+	    defstr = tv_get_string_buf_chk(&argvars[1], buf);
+	    if (defstr != NULL)
+		stuffReadbuffSpec(defstr);
+
+	    if (!inputdialog && argvars[2].v_type != VAR_UNKNOWN)
+	    {
+		char_u	*xp_name;
+		int	xp_namelen;
+		long	argt;
+
+		// input() with a third argument: completion
+		rettv->vval.v_string = NULL;
+
+		xp_name = tv_get_string_buf_chk(&argvars[2], buf);
+		if (xp_name == NULL)
+		    return;
+
+		xp_namelen = (int)STRLEN(xp_name);
+
+		if (parse_compl_arg(xp_name, xp_namelen, &xp_type, &argt,
+							     &xp_arg) == FAIL)
+		    return;
+	    }
+	}
+
+	if (defstr != NULL)
+	{
+	    int save_ex_normal_busy = ex_normal_busy;
+
+	    ex_normal_busy = 0;
+	    rettv->vval.v_string =
+		getcmdline_prompt(secret ? NUL : '@', p, get_echo_attr(),
+							      xp_type, xp_arg);
+	    ex_normal_busy = save_ex_normal_busy;
+	}
+	if (inputdialog && rettv->vval.v_string == NULL
+		&& argvars[1].v_type != VAR_UNKNOWN
+		&& argvars[2].v_type != VAR_UNKNOWN)
+	    rettv->vval.v_string = vim_strsave(tv_get_string_buf(
+							   &argvars[2], buf));
+
+	vim_free(xp_arg);
+
+	// since the user typed this, no need to wait for return
+	need_wait_return = FALSE;
+	msg_didout = FALSE;
+    }
+    cmd_silent = cmd_silent_save;
+}
+#endif

src/evalvars.c

@@ -191,9 +191,6 @@ EXTERN int	emsg_skip INIT(= 0);	    // don't display errors for
 EXTERN int	emsg_severe INIT(= FALSE);  // use message of next of several
 					    // emsg() calls for throw
 EXTERN int	did_endif INIT(= FALSE);    // just had ":endif"
-EXTERN dict_T	vimvardict;		    // Dictionary with v: variables
-EXTERN dict_T	globvardict;		    // Dictionary with g: variables
-#define globvarht globvardict.dv_hashtab
 #endif
 EXTERN int	did_emsg;		    // set by emsg() when the message
 					    // is displayed or thrown

src/ex_getln.c

@@ -6847,8 +6847,8 @@ populate_module(PyObject *m)
 	return -1;
     ADD_OBJECT(m, "error", VimError);
 
-    ADD_CHECKED_OBJECT(m, "vars",  NEW_DICTIONARY(&globvardict));
-    ADD_CHECKED_OBJECT(m, "vvars", NEW_DICTIONARY(&vimvardict));
+    ADD_CHECKED_OBJECT(m, "vars",  NEW_DICTIONARY(get_globvar_dict()));
+    ADD_CHECKED_OBJECT(m, "vvars", NEW_DICTIONARY(get_vimvar_dict()));
     ADD_CHECKED_OBJECT(m, "options",
 	    OptionsNew(SREQ_GLOBAL, NULL, dummy_check, NULL));
 

src/globals.h

@@ -3,13 +3,6 @@ varnumber_T num_divide(varnumber_T n1, varnumber_T n2);
 varnumber_T num_modulus(varnumber_T n1, varnumber_T n2);
 void eval_init(void);
 void eval_clear(void);
-int var_redir_start(char_u *name, int append);
-void var_redir_str(char_u *value, int value_len);
-void var_redir_stop(void);
-int eval_charconvert(char_u *enc_from, char_u *enc_to, char_u *fname_from, char_u *fname_to);
-int eval_printexpr(char_u *fname, char_u *args);
-void eval_diff(char_u *origfile, char_u *newfile, char_u *outfile);
-void eval_patch(char_u *origfile, char_u *difffile, char_u *outfile);
 int eval_to_bool(char_u *arg, int *error, char_u **nextcmd, int skip);
 int eval_expr_typval(typval_T *expr, typval_T *argv, int argc, typval_T *rettv);
 int eval_expr_to_bool(typval_T *expr, int *error);
@@ -33,7 +26,6 @@ void *eval_for_line(char_u *arg, int *errp, char_u **nextcmdp, int skip);
 int next_for_item(void *fi_void, char_u *arg);
 void free_for_info(void *fi_void);
 void set_context_for_expression(expand_T *xp, char_u *arg, cmdidx_T cmdidx);
-void del_menutrans_vars(void);
 int pattern_match(char_u *pat, char_u *text, int ic);
 int eval0(char_u *arg, typval_T *rettv, char_u **nextcmd, int evaluate);
 int eval1(char_u **arg, typval_T *rettv, int evaluate);
@@ -76,13 +68,11 @@ char_u *tv_get_string_chk(typval_T *varp);
 char_u *tv_get_string_buf_chk(typval_T *varp, char_u *buf);
 void copy_tv(typval_T *from, typval_T *to);
 int item_copy(typval_T *from, typval_T *to, int deep, int copyID);
-void get_user_input(typval_T *argvars, typval_T *rettv, int inputdialog, int secret);
 void ex_echo(exarg_T *eap);
 void ex_echohl(exarg_T *eap);
+int get_echo_attr(void);
 void ex_execute(exarg_T *eap);
 char_u *find_option_end(char_u **arg, int *opt_flags);
-char_u *autoload_name(char_u *name);
-int script_autoload(char_u *name, int reload);
 void last_set_msg(sctx_T script_ctx);
 int typval_compare(typval_T *typ1, typval_T *typ2, exptype_T type, int type_is, int ic);
 char_u *typval_tostring(typval_T *arg);

src/if_py_both.h

@@ -1,9 +1,14 @@
 /* evalvars.c */
 void evalvars_init(void);
 void evalvars_clear(void);
+int garbage_collect_globvars(int copyID);
 int garbage_collect_vimvars(int copyID);
 int garbage_collect_scriptvars(int copyID);
 void set_internal_string_var(char_u *name, char_u *value);
+int eval_charconvert(char_u *enc_from, char_u *enc_to, char_u *fname_from, char_u *fname_to);
+int eval_printexpr(char_u *fname, char_u *args);
+void eval_diff(char_u *origfile, char_u *newfile, char_u *outfile);
+void eval_patch(char_u *origfile, char_u *difffile, char_u *outfile);
 void prepare_vimvar(int idx, typval_T *save_tv);
 void restore_vimvar(int idx, typval_T *save_tv);
 void ex_let(exarg_T *eap);
@@ -14,7 +19,12 @@ void list_hashtable_vars(hashtab_T *ht, char *prefix, int empty, int *first);
 void ex_unlet(exarg_T *eap);
 void ex_lockvar(exarg_T *eap);
 int do_unlet(char_u *name, int forceit);
+void del_menutrans_vars(void);
 char_u *get_user_var_name(expand_T *xp, int idx);
+char *get_var_special_name(int nr);
+dict_T *get_globvar_dict(void);
+hashtab_T *get_globvar_ht(void);
+dict_T *get_vimvar_dict(void);
 void set_vim_var_type(int idx, vartype_T type);
 void set_vim_var_nr(int idx, varnumber_T val);
 typval_T *get_vim_var_tv(int idx);
@@ -44,7 +54,6 @@ void init_var_dict(dict_T *dict, dictitem_T *dict_var, int scope);
 void unref_var_dict(dict_T *dict);
 void vars_clear(hashtab_T *ht);
 void vars_clear_ext(hashtab_T *ht, int free_val);
-void delete_var(hashtab_T *ht, hashitem_T *hi);
 void set_var(char_u *name, typval_T *tv, int copy);
 void set_var_const(char_u *name, typval_T *tv, int copy, int is_const);
 int var_check_ro(int flags, char_u *name, int use_gettext);
@@ -55,6 +64,9 @@ int valid_varname(char_u *varname);
 void reset_v_option_vars(void);
 void assert_error(garray_T *gap);
 int var_exists(char_u *var);
+int var_redir_start(char_u *name, int append);
+void var_redir_str(char_u *value, int value_len);
+void var_redir_stop(void);
 void f_gettabvar(typval_T *argvars, typval_T *rettv);
 void f_gettabwinvar(typval_T *argvars, typval_T *rettv);
 void f_getwinvar(typval_T *argvars, typval_T *rettv);

src/proto/eval.pro

@@ -35,4 +35,5 @@ int get_cmdline_type(void);
 int get_cmdline_firstc(void);
 int get_list_range(char_u **str, int *num1, int *num2);
 char_u *script_get(exarg_T *eap, char_u *cmd);
+void get_user_input(typval_T *argvars, typval_T *rettv, int inputdialog, int secret);
 /* vim: set ft=c : */

src/proto/evalvars.pro

@@ -20,11 +20,14 @@ void ex_scriptnames(exarg_T *eap);
 void scriptnames_slash_adjust(void);
 char_u *get_scriptname(scid_T id);
 void free_scriptnames(void);
+void free_autoload_scriptnames(void);
 linenr_T get_sourced_lnum(char_u *(*fgetline)(int, void *, int, int), void *cookie);
 char_u *getsourceline(int c, void *cookie, int indent, int do_concat);
 void ex_scriptencoding(exarg_T *eap);
 void ex_scriptversion(exarg_T *eap);
 void ex_finish(exarg_T *eap);
 void do_finish(exarg_T *eap, int reanimate);
 int source_finished(char_u *(*fgetline)(int, void *, int, int), void *cookie);
+char_u *autoload_name(char_u *name);
+int script_autoload(char_u *name, int reload);
 /* vim: set ft=c : */

src/proto/ex_getln.pro

@@ -13,6 +13,11 @@
 
 #include "vim.h"
 
+#if defined(FEAT_EVAL) || defined(PROTO)
+// The names of packages that once were loaded are remembered.
+static garray_T		ga_loaded = {0, 0, sizeof(char_u *), 4, NULL};
+#endif
+
 /*
  * ":runtime [what] {name}"
  */
@@ -1334,6 +1339,12 @@ free_scriptnames(void)
 	vim_free(SCRIPT_ITEM(i).sn_name);
     ga_clear(&script_items);
 }
+
+    void
+free_autoload_scriptnames(void)
+{
+    ga_clear_strings(&ga_loaded);
+}
 # endif
 
 #endif
@@ -1690,4 +1701,76 @@ source_finished(
 	    && ((struct source_cookie *)getline_cookie(
 						fgetline, cookie))->finished);
 }
+
+/*
+ * Return the autoload script name for a function or variable name.
+ * Returns NULL when out of memory.
+ * Caller must make sure that "name" contains AUTOLOAD_CHAR.
+ */
+    char_u *
+autoload_name(char_u *name)
+{
+    char_u	*p, *q = NULL;
+    char_u	*scriptname;
+
+    // Get the script file name: replace '#' with '/', append ".vim".
+    scriptname = alloc(STRLEN(name) + 14);
+    if (scriptname == NULL)
+	return NULL;
+    STRCPY(scriptname, "autoload/");
+    STRCAT(scriptname, name);
+    for (p = scriptname + 9; (p = vim_strchr(p, AUTOLOAD_CHAR)) != NULL;
+								    q = p, ++p)
+	*p = '/';
+    STRCPY(q, ".vim");
+    return scriptname;
+}
+
+/*
+ * If "name" has a package name try autoloading the script for it.
+ * Return TRUE if a package was loaded.
+ */
+    int
+script_autoload(
+    char_u	*name,
+    int		reload)	    // load script again when already loaded
+{
+    char_u	*p;
+    char_u	*scriptname, *tofree;
+    int		ret = FALSE;
+    int		i;
+
+    // If there is no '#' after name[0] there is no package name.
+    p = vim_strchr(name, AUTOLOAD_CHAR);
+    if (p == NULL || p == name)
+	return FALSE;
+
+    tofree = scriptname = autoload_name(name);
+    if (scriptname == NULL)
+	return FALSE;
+
+    // Find the name in the list of previously loaded package names.  Skip
+    // "autoload/", it's always the same.
+    for (i = 0; i < ga_loaded.ga_len; ++i)
+	if (STRCMP(((char_u **)ga_loaded.ga_data)[i] + 9, scriptname + 9) == 0)
+	    break;
+    if (!reload && i < ga_loaded.ga_len)
+	ret = FALSE;	    // was loaded already
+    else
+    {
+	// Remember the name if it wasn't loaded already.
+	if (i == ga_loaded.ga_len && ga_grow(&ga_loaded, 1) == OK)
+	{
+	    ((char_u **)ga_loaded.ga_data)[ga_loaded.ga_len++] = scriptname;
+	    tofree = NULL;
+	}
+
+	// Try loading the package from $VIMRUNTIME/autoload/<name>.vim
+	if (source_runtime(scriptname, 0) == OK)
+	    ret = TRUE;
+    }
+
+    vim_free(tofree);
+    return ret;
+}
 #endif