IntenseFinance/neovim
3
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-02-25 18:55:25 -06:00
Code Issues Packages Projects Releases Wiki Activity

vim-patch:9.0.0398: members of funccall_T are inconsistently named (#23123)

Browse Source 
Problem:    Members of funccall_T are inconsistently named.
Solution:   Use the "fc_" prefix for all members.

ca16c60f33

Co-authored-by: Bram Moolenaar <Bram@vim.org>
This commit is contained in:
zeertzjq 2023-04-16 16:57:25 +08:00 committed by GitHub
parent 0b855f7c07
commit 42e55ba009
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 164 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/nvim/eval.c
View File

@ -7466,7 +7466,7 @@ hashtab_T *find_var_ht_dict(const char *name, const size_t name_len, const char
if (funccal == NULL) { // global variable if (funccal == NULL) { // global variable
*d = &globvardict; *d = &globvardict;
} else { // l: variable } else { // l: variable
*d = &funccal->l_vars; *d = &funccal->fc_l_vars;
} }
goto end; goto end;
} }
@ -7490,9 +7490,9 @@ hashtab_T *find_var_ht_dict(const char *name, const size_t name_len, const char
} else if (*name == 'v') { // v: variable } else if (*name == 'v') { // v: variable
*d = &vimvardict; *d = &vimvardict;
} else if (*name == 'a' && funccal != NULL) { // function argument } else if (*name == 'a' && funccal != NULL) { // function argument
*d = &funccal->l_avars; *d = &funccal->fc_l_avars;
} else if (*name == 'l' && funccal != NULL) { // local variable } else if (*name == 'l' && funccal != NULL) { // local variable
*d = &funccal->l_vars; *d = &funccal->fc_l_vars;
} else if (*name == 's' // script variable } else if (*name == 's' // script variable
&& (current_sctx.sc_sid > 0 || current_sctx.sc_sid == SID_STR && (current_sctx.sc_sid > 0 || current_sctx.sc_sid == SID_STR
|| current_sctx.sc_sid == SID_LUA) || current_sctx.sc_sid == SID_LUA)

43
src/nvim/eval/typval_defs.h
View File

@ -284,28 +284,27 @@ enum { FIXVAR_CNT = 12, };
typedef struct funccall_S funccall_T; typedef struct funccall_S funccall_T;
struct funccall_S { struct funccall_S {
ufunc_T *func; ///< Function being called. ufunc_T *fc_func; ///< Function being called.
int linenr; ///< Next line to be executed. int fc_linenr; ///< Next line to be executed.
int returned; ///< ":return" used. int fc_returned; ///< ":return" used.
/// Fixed variables for arguments. TV_DICTITEM_STRUCT(VAR_SHORT_LEN + 1) fc_fixvar[FIXVAR_CNT]; ///< Fixed variables for arguments.
TV_DICTITEM_STRUCT(VAR_SHORT_LEN + 1) fixvar[FIXVAR_CNT]; dict_T fc_l_vars; ///< l: local function variables.
dict_T l_vars; ///< l: local function variables. ScopeDictDictItem fc_l_vars_var; ///< Variable for l: scope.
ScopeDictDictItem l_vars_var; ///< Variable for l: scope. dict_T fc_l_avars; ///< a: argument variables.
dict_T l_avars; ///< a: argument variables. ScopeDictDictItem fc_l_avars_var; ///< Variable for a: scope.
ScopeDictDictItem l_avars_var; ///< Variable for a: scope. list_T fc_l_varlist; ///< List for a:000.
list_T l_varlist; ///< List for a:000. listitem_T fc_l_listitems[MAX_FUNC_ARGS]; ///< List items for a:000.
listitem_T l_listitems[MAX_FUNC_ARGS]; ///< List items for a:000. typval_T *fc_rettv; ///< Return value.
typval_T *rettv; ///< Return value. linenr_T fc_breakpoint; ///< Next line with breakpoint or zero.
linenr_T breakpoint; ///< Next line with breakpoint or zero. int fc_dbg_tick; ///< "debug_tick" when breakpoint was set.
int dbg_tick; ///< debug_tick when breakpoint was set. int fc_level; ///< Top nesting level of executed function.
int level; ///< Top nesting level of executed function. garray_T fc_defer; ///< Functions to be called on return.
garray_T fc_defer; ///< Functions to be called on return. proftime_T fc_prof_child; ///< Time spent in a child.
proftime_T prof_child; ///< Time spent in a child. funccall_T *fc_caller; ///< Calling function or NULL; or next funccal in
funccall_T *caller; ///< Calling function or NULL; or next funccal in ///< list pointed to by previous_funccal.
///< list pointed to by previous_funccal. int fc_refcount; ///< Number of user functions that reference this funccall.
int fc_refcount; ///< Number of user functions that reference this funccall. int fc_copyID; ///< CopyID used for garbage collection.
int fc_copyID; ///< CopyID used for garbage collection. garray_T fc_ufuncs; ///< List of ufunc_T* which keep a reference to "fc_func".
garray_T fc_funcs; ///< List of ufunc_T* which keep a reference to "func".
}; };
/// Structure to hold info for a user function. /// Structure to hold info for a user function.

256
src/nvim/eval/userfunc.c
View File

@ -235,9 +235,9 @@ static void register_closure(ufunc_T *fp)
funccal_unref(fp->uf_scoped, fp, false); funccal_unref(fp->uf_scoped, fp, false);
fp->uf_scoped = current_funccal; fp->uf_scoped = current_funccal;
current_funccal->fc_refcount++; current_funccal->fc_refcount++;
ga_grow(&current_funccal->fc_funcs, 1); ga_grow(&current_funccal->fc_ufuncs, 1);
((ufunc_T **)current_funccal->fc_funcs.ga_data) ((ufunc_T **)current_funccal->fc_ufuncs.ga_data)
[current_funccal->fc_funcs.ga_len++] = fp; [current_funccal->fc_ufuncs.ga_len++] = fp;
} }
/// @return a name for a lambda. Returned in static memory. /// @return a name for a lambda. Returned in static memory.
@ -678,8 +678,8 @@ static void add_nr_var(dict_T *dp, dictitem_T *v, char *name, varnumber_T nr)
/// Free "fc" /// Free "fc"
static void free_funccal(funccall_T *fc) static void free_funccal(funccall_T *fc)
{ {
for (int i = 0; i < fc->fc_funcs.ga_len; i++) { for (int i = 0; i < fc->fc_ufuncs.ga_len; i++) {
ufunc_T *fp = ((ufunc_T **)(fc->fc_funcs.ga_data))[i]; ufunc_T *fp = ((ufunc_T **)(fc->fc_ufuncs.ga_data))[i];
// When garbage collecting a funccall_T may be freed before the // When garbage collecting a funccall_T may be freed before the
// function that references it, clear its uf_scoped field. // function that references it, clear its uf_scoped field.
@ -689,9 +689,9 @@ static void free_funccal(funccall_T *fc)
fp->uf_scoped = NULL; fp->uf_scoped = NULL;
} }
} }
ga_clear(&fc->fc_funcs); ga_clear(&fc->fc_ufuncs);
func_ptr_unref(fc->func); func_ptr_unref(fc->fc_func);
xfree(fc); xfree(fc);
} }
@ -701,13 +701,13 @@ static void free_funccal(funccall_T *fc)
static void free_funccal_contents(funccall_T *fc) static void free_funccal_contents(funccall_T *fc)
{ {
// Free all l: variables. // Free all l: variables.
vars_clear(&fc->l_vars.dv_hashtab); vars_clear(&fc->fc_l_vars.dv_hashtab);
// Free all a: variables. // Free all a: variables.
vars_clear(&fc->l_avars.dv_hashtab); vars_clear(&fc->fc_l_avars.dv_hashtab);
// Free the a:000 variables. // Free the a:000 variables.
TV_LIST_ITER(&fc->l_varlist, li, { TV_LIST_ITER(&fc->fc_l_varlist, li, {
tv_clear(TV_LIST_ITEM_TV(li)); tv_clear(TV_LIST_ITEM_TV(li));
}); });
@ -721,11 +721,11 @@ static void cleanup_function_call(funccall_T *fc)
bool may_free_fc = fc->fc_refcount <= 0; bool may_free_fc = fc->fc_refcount <= 0;
bool free_fc = true; bool free_fc = true;
current_funccal = fc->caller; current_funccal = fc->fc_caller;
// Free all l: variables if not referred. // Free all l: variables if not referred.
if (may_free_fc && fc->l_vars.dv_refcount == DO_NOT_FREE_CNT) { if (may_free_fc && fc->fc_l_vars.dv_refcount == DO_NOT_FREE_CNT) {
vars_clear(&fc->l_vars.dv_hashtab); vars_clear(&fc->fc_l_vars.dv_hashtab);
} else { } else {
free_fc = false; free_fc = false;
} }
@ -733,25 +733,25 @@ static void cleanup_function_call(funccall_T *fc)
// If the a:000 list and the l: and a: dicts are not referenced and // If the a:000 list and the l: and a: dicts are not referenced and
// there is no closure using it, we can free the funccall_T and what's // there is no closure using it, we can free the funccall_T and what's
// in it. // in it.
if (may_free_fc && fc->l_avars.dv_refcount == DO_NOT_FREE_CNT) { if (may_free_fc && fc->fc_l_avars.dv_refcount == DO_NOT_FREE_CNT) {
vars_clear_ext(&fc->l_avars.dv_hashtab, false); vars_clear_ext(&fc->fc_l_avars.dv_hashtab, false);
} else { } else {
free_fc = false; free_fc = false;
// Make a copy of the a: variables, since we didn't do that above. // Make a copy of the a: variables, since we didn't do that above.
TV_DICT_ITER(&fc->l_avars, di, { TV_DICT_ITER(&fc->fc_l_avars, di, {
tv_copy(&di->di_tv, &di->di_tv); tv_copy(&di->di_tv, &di->di_tv);
}); });
} }
if (may_free_fc && fc->l_varlist.lv_refcount // NOLINT(runtime/deprecated) if (may_free_fc && fc->fc_l_varlist.lv_refcount // NOLINT(runtime/deprecated)
== DO_NOT_FREE_CNT) { == DO_NOT_FREE_CNT) {
fc->l_varlist.lv_first = NULL; // NOLINT(runtime/deprecated) fc->fc_l_varlist.lv_first = NULL; // NOLINT(runtime/deprecated)
} else { } else {
free_fc = false; free_fc = false;
// Make a copy of the a:000 items, since we didn't do that above. // Make a copy of the a:000 items, since we didn't do that above.
TV_LIST_ITER(&fc->l_varlist, li, { TV_LIST_ITER(&fc->fc_l_varlist, li, {
tv_copy(TV_LIST_ITEM_TV(li), TV_LIST_ITEM_TV(li)); tv_copy(TV_LIST_ITEM_TV(li), TV_LIST_ITEM_TV(li));
}); });
} }
@ -764,7 +764,7 @@ static void cleanup_function_call(funccall_T *fc)
// "fc" is still in use. This can happen when returning "a:000", // "fc" is still in use. This can happen when returning "a:000",
// assigning "l:" to a global variable or defining a closure. // assigning "l:" to a global variable or defining a closure.
// Link "fc" in the list for garbage collection later. // Link "fc" in the list for garbage collection later.
fc->caller = previous_funccal; fc->fc_caller = previous_funccal;
previous_funccal = fc; previous_funccal = fc;
if (want_garbage_collect) { if (want_garbage_collect) {
@ -795,17 +795,17 @@ static void funccal_unref(funccall_T *fc, ufunc_T *fp, bool force)
fc->fc_refcount--; fc->fc_refcount--;
if (force ? fc->fc_refcount <= 0 : !fc_referenced(fc)) { if (force ? fc->fc_refcount <= 0 : !fc_referenced(fc)) {
for (funccall_T **pfc = &previous_funccal; *pfc != NULL; pfc = &(*pfc)->caller) { for (funccall_T **pfc = &previous_funccal; *pfc != NULL; pfc = &(*pfc)->fc_caller) {
if (fc == *pfc) { if (fc == *pfc) {
*pfc = fc->caller; *pfc = fc->fc_caller;
free_funccal_contents(fc); free_funccal_contents(fc);
return; return;
} }
} }
} }
for (i = 0; i < fc->fc_funcs.ga_len; i++) { for (i = 0; i < fc->fc_ufuncs.ga_len; i++) {
if (((ufunc_T **)(fc->fc_funcs.ga_data))[i] == fp) { if (((ufunc_T **)(fc->fc_ufuncs.ga_data))[i] == fp) {
((ufunc_T **)(fc->fc_funcs.ga_data))[i] = NULL; ((ufunc_T **)(fc->fc_ufuncs.ga_data))[i] = NULL;
} }
} }
} }
@ -899,7 +899,7 @@ void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rett
int save_did_emsg; int save_did_emsg;
static int depth = 0; static int depth = 0;
dictitem_T *v; dictitem_T *v;
int fixvar_idx = 0; // index in fixvar[] int fixvar_idx = 0; // index in fc_fixvar[]
int ai; int ai;
bool islambda = false; bool islambda = false;
char numbuf[NUMBUFLEN]; char numbuf[NUMBUFLEN];
@ -931,39 +931,39 @@ void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rett
line_breakcheck(); line_breakcheck();
// prepare the funccall_T structure // prepare the funccall_T structure
fc = xcalloc(1, sizeof(funccall_T)); fc = xcalloc(1, sizeof(funccall_T));
fc->caller = current_funccal; fc->fc_caller = current_funccal;
current_funccal = fc; current_funccal = fc;
fc->func = fp; fc->fc_func = fp;
fc->rettv = rettv; fc->fc_rettv = rettv;
fc->level = ex_nesting_level; fc->fc_level = ex_nesting_level;
// Check if this function has a breakpoint. // Check if this function has a breakpoint.
fc->breakpoint = dbg_find_breakpoint(false, fp->uf_name, (linenr_T)0); fc->fc_breakpoint = dbg_find_breakpoint(false, fp->uf_name, (linenr_T)0);
fc->dbg_tick = debug_tick; fc->fc_dbg_tick = debug_tick;
// Set up fields for closure. // Set up fields for closure.
ga_init(&fc->fc_funcs, sizeof(ufunc_T *), 1); ga_init(&fc->fc_ufuncs, sizeof(ufunc_T *), 1);
func_ptr_ref(fp); func_ptr_ref(fp);
if (strncmp(fp->uf_name, "<lambda>", 8) == 0) { if (strncmp(fp->uf_name, "<lambda>", 8) == 0) {
islambda = true; islambda = true;
} }
// Note about using fc->fixvar[]: This is an array of FIXVAR_CNT variables // Note about using fc->fc_fixvar[]: This is an array of FIXVAR_CNT variables
// with names up to VAR_SHORT_LEN long. This avoids having to alloc/free // with names up to VAR_SHORT_LEN long. This avoids having to alloc/free
// each argument variable and saves a lot of time. // each argument variable and saves a lot of time.
// //
// Init l: variables. // Init l: variables.
init_var_dict(&fc->l_vars, &fc->l_vars_var, VAR_DEF_SCOPE); init_var_dict(&fc->fc_l_vars, &fc->fc_l_vars_var, VAR_DEF_SCOPE);
if (selfdict != NULL) { if (selfdict != NULL) {
// Set l:self to "selfdict". Use "name" to avoid a warning from // Set l:self to "selfdict". Use "name" to avoid a warning from
// some compiler that checks the destination size. // some compiler that checks the destination size.
v = (dictitem_T *)&fc->fixvar[fixvar_idx++]; v = (dictitem_T *)&fc->fc_fixvar[fixvar_idx++];
#ifndef __clang_analyzer__ #ifndef __clang_analyzer__
name = (char *)v->di_key; name = (char *)v->di_key;
STRCPY(name, "self"); STRCPY(name, "self");
#endif #endif
v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX; v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX;
hash_add(&fc->l_vars.dv_hashtab, v->di_key); hash_add(&fc->fc_l_vars.dv_hashtab, v->di_key);
v->di_tv.v_type = VAR_DICT; v->di_tv.v_type = VAR_DICT;
v->di_tv.v_lock = VAR_UNLOCKED; v->di_tv.v_lock = VAR_UNLOCKED;
v->di_tv.vval.v_dict = selfdict; v->di_tv.vval.v_dict = selfdict;
@ -973,38 +973,38 @@ void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rett
// Init a: variables, unless none found (in lambda). // Init a: variables, unless none found (in lambda).
// Set a:0 to "argcount" less number of named arguments, if >= 0. // Set a:0 to "argcount" less number of named arguments, if >= 0.
// Set a:000 to a list with room for the "..." arguments. // Set a:000 to a list with room for the "..." arguments.
init_var_dict(&fc->l_avars, &fc->l_avars_var, VAR_SCOPE); init_var_dict(&fc->fc_l_avars, &fc->fc_l_avars_var, VAR_SCOPE);
if ((fp->uf_flags & FC_NOARGS) == 0) { if ((fp->uf_flags & FC_NOARGS) == 0) {
add_nr_var(&fc->l_avars, (dictitem_T *)&fc->fixvar[fixvar_idx++], "0", add_nr_var(&fc->fc_l_avars, (dictitem_T *)&fc->fc_fixvar[fixvar_idx++], "0",
(varnumber_T)(argcount >= fp->uf_args.ga_len (varnumber_T)(argcount >= fp->uf_args.ga_len
? argcount - fp->uf_args.ga_len : 0)); ? argcount - fp->uf_args.ga_len : 0));
} }
fc->l_avars.dv_lock = VAR_FIXED; fc->fc_l_avars.dv_lock = VAR_FIXED;
if ((fp->uf_flags & FC_NOARGS) == 0) { if ((fp->uf_flags & FC_NOARGS) == 0) {
// Use "name" to avoid a warning from some compiler that checks the // Use "name" to avoid a warning from some compiler that checks the
// destination size. // destination size.
v = (dictitem_T *)&fc->fixvar[fixvar_idx++]; v = (dictitem_T *)&fc->fc_fixvar[fixvar_idx++];
#ifndef __clang_analyzer__ #ifndef __clang_analyzer__
name = (char *)v->di_key; name = (char *)v->di_key;
STRCPY(name, "000"); STRCPY(name, "000");
#endif #endif
v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX; v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX;
hash_add(&fc->l_avars.dv_hashtab, v->di_key); hash_add(&fc->fc_l_avars.dv_hashtab, v->di_key);
v->di_tv.v_type = VAR_LIST; v->di_tv.v_type = VAR_LIST;
v->di_tv.v_lock = VAR_FIXED; v->di_tv.v_lock = VAR_FIXED;
v->di_tv.vval.v_list = &fc->l_varlist; v->di_tv.vval.v_list = &fc->fc_l_varlist;
} }
tv_list_init_static(&fc->l_varlist); tv_list_init_static(&fc->fc_l_varlist);
tv_list_set_lock(&fc->l_varlist, VAR_FIXED); tv_list_set_lock(&fc->fc_l_varlist, VAR_FIXED);
// Set a:firstline to "firstline" and a:lastline to "lastline". // Set a:firstline to "firstline" and a:lastline to "lastline".
// Set a:name to named arguments. // Set a:name to named arguments.
// Set a:N to the "..." arguments. // Set a:N to the "..." arguments.
// Skipped when no a: variables used (in lambda). // Skipped when no a: variables used (in lambda).
if ((fp->uf_flags & FC_NOARGS) == 0) { if ((fp->uf_flags & FC_NOARGS) == 0) {
add_nr_var(&fc->l_avars, (dictitem_T *)&fc->fixvar[fixvar_idx++], add_nr_var(&fc->fc_l_avars, (dictitem_T *)&fc->fc_fixvar[fixvar_idx++],
"firstline", (varnumber_T)firstline); "firstline", (varnumber_T)firstline);
add_nr_var(&fc->l_avars, (dictitem_T *)&fc->fixvar[fixvar_idx++], add_nr_var(&fc->fc_l_avars, (dictitem_T *)&fc->fc_fixvar[fixvar_idx++],
"lastline", (varnumber_T)lastline); "lastline", (varnumber_T)lastline);
} }
bool default_arg_err = false; bool default_arg_err = false;
@ -1045,7 +1045,7 @@ void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rett
name = numbuf; name = numbuf;
} }
if (fixvar_idx < FIXVAR_CNT && strlen(name) <= VAR_SHORT_LEN) { if (fixvar_idx < FIXVAR_CNT && strlen(name) <= VAR_SHORT_LEN) {
v = (dictitem_T *)&fc->fixvar[fixvar_idx++]; v = (dictitem_T *)&fc->fc_fixvar[fixvar_idx++];
v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX; v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX;
} else { } else {
v = xmalloc(sizeof(dictitem_T) + strlen(name)); v = xmalloc(sizeof(dictitem_T) + strlen(name));
@ -1067,17 +1067,17 @@ void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rett
// Named arguments can be accessed without the "a:" prefix in lambda // Named arguments can be accessed without the "a:" prefix in lambda
// expressions. Add to the l: dict. // expressions. Add to the l: dict.
tv_copy(&v->di_tv, &v->di_tv); tv_copy(&v->di_tv, &v->di_tv);
hash_add(&fc->l_vars.dv_hashtab, v->di_key); hash_add(&fc->fc_l_vars.dv_hashtab, v->di_key);
} else { } else {
hash_add(&fc->l_avars.dv_hashtab, v->di_key); hash_add(&fc->fc_l_avars.dv_hashtab, v->di_key);
} }
if (ai >= 0 && ai < MAX_FUNC_ARGS) { if (ai >= 0 && ai < MAX_FUNC_ARGS) {
listitem_T *li = &fc->l_listitems[ai]; listitem_T *li = &fc->fc_l_listitems[ai];
*TV_LIST_ITEM_TV(li) = argvars[i]; *TV_LIST_ITEM_TV(li) = argvars[i];
TV_LIST_ITEM_TV(li)->v_lock = VAR_FIXED; TV_LIST_ITEM_TV(li)->v_lock = VAR_FIXED;
tv_list_append(&fc->l_varlist, li); tv_list_append(&fc->fc_l_varlist, li);
} }
} }
@ -1142,7 +1142,7 @@ void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rett
bool func_or_func_caller_profiling = bool func_or_func_caller_profiling =
do_profiling_yes do_profiling_yes
&& (fp->uf_profiling && (fp->uf_profiling
|| (fc->caller != NULL && fc->caller->func->uf_profiling)); || (fc->fc_caller != NULL && fc->fc_caller->fc_func->uf_profiling));
if (func_or_func_caller_profiling) { if (func_or_func_caller_profiling) {
fp->uf_tm_count++; fp->uf_tm_count++;
@ -1194,11 +1194,11 @@ void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rett
fp->uf_tm_total = profile_add(fp->uf_tm_total, call_start); fp->uf_tm_total = profile_add(fp->uf_tm_total, call_start);
fp->uf_tm_self = profile_self(fp->uf_tm_self, call_start, fp->uf_tm_self = profile_self(fp->uf_tm_self, call_start,
fp->uf_tm_children); fp->uf_tm_children);
if (fc->caller != NULL && fc->caller->func->uf_profiling) { if (fc->fc_caller != NULL && fc->fc_caller->fc_func->uf_profiling) {
fc->caller->func->uf_tm_children = fc->fc_caller->fc_func->uf_tm_children =
profile_add(fc->caller->func->uf_tm_children, call_start); profile_add(fc->fc_caller->fc_func->uf_tm_children, call_start);
fc->caller->func->uf_tml_children = fc->fc_caller->fc_func->uf_tml_children =
profile_add(fc->caller->func->uf_tml_children, call_start); profile_add(fc->fc_caller->fc_func->uf_tml_children, call_start);
} }
if (started_profiling) { if (started_profiling) {
// make a ":profdel func" stop profiling the function // make a ":profdel func" stop profiling the function
@ -1213,9 +1213,9 @@ void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rett
if (aborting()) { if (aborting()) {
smsg(_("%s aborted"), SOURCING_NAME); smsg(_("%s aborted"), SOURCING_NAME);
} else if (fc->rettv->v_type == VAR_NUMBER) { } else if (fc->fc_rettv->v_type == VAR_NUMBER) {
smsg(_("%s returning #%" PRId64 ""), smsg(_("%s returning #%" PRId64 ""),
SOURCING_NAME, (int64_t)fc->rettv->vval.v_number); SOURCING_NAME, (int64_t)fc->fc_rettv->vval.v_number);
} else { } else {
char buf[MSG_BUF_LEN]; char buf[MSG_BUF_LEN];
@ -1223,7 +1223,7 @@ void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rett
// have some idea how it starts and ends. smsg() would always // have some idea how it starts and ends. smsg() would always
// truncate it at the end. Don't want errors such as E724 here. // truncate it at the end. Don't want errors such as E724 here.
emsg_off++; emsg_off++;
char *s = encode_tv2string(fc->rettv, NULL); char *s = encode_tv2string(fc->fc_rettv, NULL);
char *tofree = s; char *tofree = s;
emsg_off--; emsg_off--;
if (s != NULL) { if (s != NULL) {
@ -1361,7 +1361,7 @@ void free_all_functions(void)
// Clean up the current_funccal chain and the funccal stack. // Clean up the current_funccal chain and the funccal stack.
while (current_funccal != NULL) { while (current_funccal != NULL) {
tv_clear(current_funccal->rettv); tv_clear(current_funccal->fc_rettv);
cleanup_function_call(current_funccal); // -V595 cleanup_function_call(current_funccal); // -V595
if (current_funccal == NULL && funccal_stack != NULL) { if (current_funccal == NULL && funccal_stack != NULL) {
restore_funccal(); restore_funccal();
@ -2994,10 +2994,10 @@ static inline bool fc_referenced(const funccall_T *const fc)
FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_ALWAYS_INLINE FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
FUNC_ATTR_NONNULL_ALL FUNC_ATTR_NONNULL_ALL
{ {
return ((fc->l_varlist.lv_refcount // NOLINT(runtime/deprecated) return ((fc->fc_l_varlist.lv_refcount // NOLINT(runtime/deprecated)
!= DO_NOT_FREE_CNT) != DO_NOT_FREE_CNT)
|| fc->l_vars.dv_refcount != DO_NOT_FREE_CNT || fc->fc_l_vars.dv_refcount != DO_NOT_FREE_CNT
|| fc->l_avars.dv_refcount != DO_NOT_FREE_CNT || fc->fc_l_avars.dv_refcount != DO_NOT_FREE_CNT
|| fc->fc_refcount > 0); || fc->fc_refcount > 0);
} }
@ -3005,9 +3005,9 @@ static inline bool fc_referenced(const funccall_T *const fc)
/// referenced from anywhere that is in use. /// referenced from anywhere that is in use.
static int can_free_funccal(funccall_T *fc, int copyID) static int can_free_funccal(funccall_T *fc, int copyID)
{ {
return fc->l_varlist.lv_copyID != copyID return fc->fc_l_varlist.lv_copyID != copyID
&& fc->l_vars.dv_copyID != copyID && fc->fc_l_vars.dv_copyID != copyID
&& fc->l_avars.dv_copyID != copyID && fc->fc_l_avars.dv_copyID != copyID
&& fc->fc_copyID != copyID; && fc->fc_copyID != copyID;
} }
@ -3206,7 +3206,7 @@ static void handle_defer_one(funccall_T *funccal)
/// Called when exiting: call all defer functions. /// Called when exiting: call all defer functions.
void invoke_all_defer(void) void invoke_all_defer(void)
{ {
for (funccall_T *funccal = current_funccal; funccal != NULL; funccal = funccal->caller) { for (funccall_T *funccal = current_funccal; funccal != NULL; funccal = funccal->fc_caller) {
handle_defer_one(funccal); handle_defer_one(funccal);
} }
} }
@ -3323,7 +3323,7 @@ int do_return(exarg_T *eap, int reanimate, int is_cmd, void *rettv)
if (reanimate) { if (reanimate) {
// Undo the return. // Undo the return.
current_funccal->returned = false; current_funccal->fc_returned = false;
} }
// Cleanup (and deactivate) conditionals, but stop when a try conditional // Cleanup (and deactivate) conditionals, but stop when a try conditional
@ -3343,8 +3343,8 @@ int do_return(exarg_T *eap, int reanimate, int is_cmd, void *rettv)
// When undoing a return in order to make it pending, get the stored // When undoing a return in order to make it pending, get the stored
// return rettv. // return rettv.
if (reanimate) { if (reanimate) {
assert(current_funccal->rettv); assert(current_funccal->fc_rettv);
rettv = current_funccal->rettv; rettv = current_funccal->fc_rettv;
} }
if (rettv != NULL) { if (rettv != NULL) {
@ -3359,20 +3359,20 @@ int do_return(exarg_T *eap, int reanimate, int is_cmd, void *rettv)
// The pending return value could be overwritten by a ":return" // The pending return value could be overwritten by a ":return"
// without argument in a finally clause; reset the default // without argument in a finally clause; reset the default
// return value. // return value.
current_funccal->rettv->v_type = VAR_NUMBER; current_funccal->fc_rettv->v_type = VAR_NUMBER;
current_funccal->rettv->vval.v_number = 0; current_funccal->fc_rettv->vval.v_number = 0;
} }
} }
report_make_pending(CSTP_RETURN, rettv); report_make_pending(CSTP_RETURN, rettv);
} else { } else {
current_funccal->returned = true; current_funccal->fc_returned = true;
// If the return is carried out now, store the return value. For // If the return is carried out now, store the return value. For
// a return immediately after reanimation, the value is already // a return immediately after reanimation, the value is already
// there. // there.
if (!reanimate && rettv != NULL) { if (!reanimate && rettv != NULL) {
tv_clear(current_funccal->rettv); tv_clear(current_funccal->fc_rettv);
*current_funccal->rettv = *(typval_T *)rettv; *current_funccal->fc_rettv = *(typval_T *)rettv;
if (!is_cmd) { if (!is_cmd) {
xfree(rettv); xfree(rettv);
} }
@ -3412,14 +3412,14 @@ char *get_return_cmd(void *rettv)
char *get_func_line(int c, void *cookie, int indent, bool do_concat) char *get_func_line(int c, void *cookie, int indent, bool do_concat)
{ {
funccall_T *fcp = (funccall_T *)cookie; funccall_T *fcp = (funccall_T *)cookie;
ufunc_T *fp = fcp->func; ufunc_T *fp = fcp->fc_func;
char *retval; char *retval;
garray_T *gap; // growarray with function lines garray_T *gap; // growarray with function lines
// If breakpoints have been added/deleted need to check for it. // If breakpoints have been added/deleted need to check for it.
if (fcp->dbg_tick != debug_tick) { if (fcp->fc_dbg_tick != debug_tick) {
fcp->breakpoint = dbg_find_breakpoint(false, fp->uf_name, SOURCING_LNUM); fcp->fc_breakpoint = dbg_find_breakpoint(false, fp->uf_name, SOURCING_LNUM);
fcp->dbg_tick = debug_tick; fcp->fc_dbg_tick = debug_tick;
} }
if (do_profiling == PROF_YES) { if (do_profiling == PROF_YES) {
func_line_end(cookie); func_line_end(cookie);
@ -3427,19 +3427,19 @@ char *get_func_line(int c, void *cookie, int indent, bool do_concat)
gap = &fp->uf_lines; gap = &fp->uf_lines;
if (((fp->uf_flags & FC_ABORT) && did_emsg && !aborted_in_try()) if (((fp->uf_flags & FC_ABORT) && did_emsg && !aborted_in_try())
|| fcp->returned) { || fcp->fc_returned) {
retval = NULL; retval = NULL;
} else { } else {
// Skip NULL lines (continuation lines). // Skip NULL lines (continuation lines).
while (fcp->linenr < gap->ga_len while (fcp->fc_linenr < gap->ga_len
&& ((char **)(gap->ga_data))[fcp->linenr] == NULL) { && ((char **)(gap->ga_data))[fcp->fc_linenr] == NULL) {
fcp->linenr++; fcp->fc_linenr++;
} }
if (fcp->linenr >= gap->ga_len) { if (fcp->fc_linenr >= gap->ga_len) {
retval = NULL; retval = NULL;
} else { } else {
retval = xstrdup(((char **)(gap->ga_data))[fcp->linenr++]); retval = xstrdup(((char **)(gap->ga_data))[fcp->fc_linenr++]);
SOURCING_LNUM = fcp->linenr; SOURCING_LNUM = fcp->fc_linenr;
if (do_profiling == PROF_YES) { if (do_profiling == PROF_YES) {
func_line_start(cookie); func_line_start(cookie);
} }
@ -3447,11 +3447,11 @@ char *get_func_line(int c, void *cookie, int indent, bool do_concat)
} }
// Did we encounter a breakpoint? // Did we encounter a breakpoint?
if (fcp->breakpoint != 0 && fcp->breakpoint <= SOURCING_LNUM) { if (fcp->fc_breakpoint != 0 && fcp->fc_breakpoint <= SOURCING_LNUM) {
dbg_breakpoint(fp->uf_name, SOURCING_LNUM); dbg_breakpoint(fp->uf_name, SOURCING_LNUM);
// Find next breakpoint. // Find next breakpoint.
fcp->breakpoint = dbg_find_breakpoint(false, fp->uf_name, SOURCING_LNUM); fcp->fc_breakpoint = dbg_find_breakpoint(false, fp->uf_name, SOURCING_LNUM);
fcp->dbg_tick = debug_tick; fcp->fc_dbg_tick = debug_tick;
} }
return retval; return retval;
@ -3465,14 +3465,14 @@ int func_has_ended(void *cookie)
// Ignore the "abort" flag if the abortion behavior has been changed due to // Ignore the "abort" flag if the abortion behavior has been changed due to
// an error inside a try conditional. // an error inside a try conditional.
return ((fcp->func->uf_flags & FC_ABORT) && did_emsg && !aborted_in_try()) return ((fcp->fc_func->uf_flags & FC_ABORT) && did_emsg && !aborted_in_try())
|| fcp->returned; || fcp->fc_returned;
} }
/// @return true if cookie indicates a function which "abort"s on errors. /// @return true if cookie indicates a function which "abort"s on errors.
int func_has_abort(void *cookie) int func_has_abort(void *cookie)
{ {
return ((funccall_T *)cookie)->func->uf_flags & FC_ABORT; return ((funccall_T *)cookie)->fc_func->uf_flags & FC_ABORT;
} }
/// Turn "dict.Func" into a partial for "Func" bound to "dict". /// Turn "dict.Func" into a partial for "Func" bound to "dict".
@ -3537,31 +3537,31 @@ void make_partial(dict_T *const selfdict, typval_T *const rettv)
/// @return the name of the executed function. /// @return the name of the executed function.
char *func_name(void *cookie) char *func_name(void *cookie)
{ {
return ((funccall_T *)cookie)->func->uf_name; return ((funccall_T *)cookie)->fc_func->uf_name;
} }
/// @return the address holding the next breakpoint line for a funccall cookie. /// @return the address holding the next breakpoint line for a funccall cookie.
linenr_T *func_breakpoint(void *cookie) linenr_T *func_breakpoint(void *cookie)
{ {
return &((funccall_T *)cookie)->breakpoint; return &((funccall_T *)cookie)->fc_breakpoint;
} }
/// @return the address holding the debug tick for a funccall cookie. /// @return the address holding the debug tick for a funccall cookie.
int *func_dbg_tick(void *cookie) int *func_dbg_tick(void *cookie)
{ {
return &((funccall_T *)cookie)->dbg_tick; return &((funccall_T *)cookie)->fc_dbg_tick;
} }
/// @return the nesting level for a funccall cookie. /// @return the nesting level for a funccall cookie.
int func_level(void *cookie) int func_level(void *cookie)
{ {
return ((funccall_T *)cookie)->level; return ((funccall_T *)cookie)->fc_level;
} }
/// @return true when a function was ended by a ":return" command. /// @return true when a function was ended by a ":return" command.
int current_func_returned(void) int current_func_returned(void)
{ {
return current_funccal->returned; return current_funccal->fc_returned;
} }
bool free_unref_funccal(int copyID, int testing) bool free_unref_funccal(int copyID, int testing)
@ -3572,12 +3572,12 @@ bool free_unref_funccal(int copyID, int testing)
for (funccall_T **pfc = &previous_funccal; *pfc != NULL;) { for (funccall_T **pfc = &previous_funccal; *pfc != NULL;) {
if (can_free_funccal(*pfc, copyID)) { if (can_free_funccal(*pfc, copyID)) {
funccall_T *fc = *pfc; funccall_T *fc = *pfc;
*pfc = fc->caller; *pfc = fc->fc_caller;
free_funccal_contents(fc); free_funccal_contents(fc);
did_free = true; did_free = true;
did_free_funccal = true; did_free_funccal = true;
} else { } else {
pfc = &(*pfc)->caller; pfc = &(*pfc)->fc_caller;
} }
} }
if (did_free_funccal) { if (did_free_funccal) {
@ -3594,7 +3594,7 @@ funccall_T *get_funccal(void)
funccall_T *funccal = current_funccal; funccall_T *funccal = current_funccal;
if (debug_backtrace_level > 0) { if (debug_backtrace_level > 0) {
for (int i = 0; i < debug_backtrace_level; i++) { for (int i = 0; i < debug_backtrace_level; i++) {
funccall_T *temp_funccal = funccal->caller; funccall_T *temp_funccal = funccal->fc_caller;
if (temp_funccal) { if (temp_funccal) {
funccal = temp_funccal; funccal = temp_funccal;
} else { } else {
@ -3614,7 +3614,7 @@ hashtab_T *get_funccal_local_ht(void)
if (current_funccal == NULL) { if (current_funccal == NULL) {
return NULL; return NULL;
} }
return &get_funccal()->l_vars.dv_hashtab; return &get_funccal()->fc_l_vars.dv_hashtab;
} }
/// @return the l: scope variable or /// @return the l: scope variable or
@ -3624,7 +3624,7 @@ dictitem_T *get_funccal_local_var(void)
if (current_funccal == NULL) { if (current_funccal == NULL) {
return NULL; return NULL;
} }
return (dictitem_T *)&get_funccal()->l_vars_var; return (dictitem_T *)&get_funccal()->fc_l_vars_var;
} }
/// @return the hashtable used for argument in the current funccal or /// @return the hashtable used for argument in the current funccal or
@ -3634,7 +3634,7 @@ hashtab_T *get_funccal_args_ht(void)
if (current_funccal == NULL) { if (current_funccal == NULL) {
return NULL; return NULL;
} }
return &get_funccal()->l_avars.dv_hashtab; return &get_funccal()->fc_l_avars.dv_hashtab;
} }
/// @return the a: scope variable or /// @return the a: scope variable or
@ -3644,14 +3644,14 @@ dictitem_T *get_funccal_args_var(void)
if (current_funccal == NULL) { if (current_funccal == NULL) {
return NULL; return NULL;
} }
return (dictitem_T *)&current_funccal->l_avars_var; return (dictitem_T *)&current_funccal->fc_l_avars_var;
} }
/// List function variables, if there is a function. /// List function variables, if there is a function.
void list_func_vars(int *first) void list_func_vars(int *first)
{ {
if (current_funccal != NULL) { if (current_funccal != NULL) {
list_hashtable_vars(&current_funccal->l_vars.dv_hashtab, "l:", false, list_hashtable_vars(&current_funccal->fc_l_vars.dv_hashtab, "l:", false,
first); first);
} }
} }
@ -3660,8 +3660,8 @@ void list_func_vars(int *first)
/// funccal, return the dict that contains it. Otherwise return NULL. /// funccal, return the dict that contains it. Otherwise return NULL.
dict_T *get_current_funccal_dict(hashtab_T *ht) dict_T *get_current_funccal_dict(hashtab_T *ht)
{ {
if (current_funccal != NULL && ht == &current_funccal->l_vars.dv_hashtab) { if (current_funccal != NULL && ht == &current_funccal->fc_l_vars.dv_hashtab) {
return &current_funccal->l_vars; return &current_funccal->fc_l_vars;
} }
return NULL; return NULL;
} }
@ -3669,7 +3669,7 @@ dict_T *get_current_funccal_dict(hashtab_T *ht)
/// Search hashitem in parent scope. /// Search hashitem in parent scope.
hashitem_T *find_hi_in_scoped_ht(const char *name, hashtab_T **pht) hashitem_T *find_hi_in_scoped_ht(const char *name, hashtab_T **pht)
{ {
if (current_funccal == NULL || current_funccal->func->uf_scoped == NULL) { if (current_funccal == NULL || current_funccal->fc_func->uf_scoped == NULL) {
return NULL; return NULL;
} }
@ -3679,7 +3679,7 @@ hashitem_T *find_hi_in_scoped_ht(const char *name, hashtab_T **pht)
const char *varname; const char *varname;
// Search in parent scope which is possible to reference from lambda // Search in parent scope which is possible to reference from lambda
current_funccal = current_funccal->func->uf_scoped; current_funccal = current_funccal->fc_func->uf_scoped;
while (current_funccal != NULL) { while (current_funccal != NULL) {
hashtab_T *ht = find_var_ht(name, namelen, &varname); hashtab_T *ht = find_var_ht(name, namelen, &varname);
if (ht != NULL && *varname != NUL) { if (ht != NULL && *varname != NUL) {
@ -3689,10 +3689,10 @@ hashitem_T *find_hi_in_scoped_ht(const char *name, hashtab_T **pht)
break; break;
} }
} }
if (current_funccal == current_funccal->func->uf_scoped) { if (current_funccal == current_funccal->fc_func->uf_scoped) {
break; break;
} }
current_funccal = current_funccal->func->uf_scoped; current_funccal = current_funccal->fc_func->uf_scoped;
} }
current_funccal = old_current_funccal; current_funccal = old_current_funccal;
@ -3702,7 +3702,7 @@ hashitem_T *find_hi_in_scoped_ht(const char *name, hashtab_T **pht)
/// Search variable in parent scope. /// Search variable in parent scope.
dictitem_T *find_var_in_scoped_ht(const char *name, const size_t namelen, int no_autoload) dictitem_T *find_var_in_scoped_ht(const char *name, const size_t namelen, int no_autoload)
{ {
if (current_funccal == NULL || current_funccal->func->uf_scoped == NULL) { if (current_funccal == NULL || current_funccal->fc_func->uf_scoped == NULL) {
return NULL; return NULL;
} }
@ -3711,7 +3711,7 @@ dictitem_T *find_var_in_scoped_ht(const char *name, const size_t namelen, int no
const char *varname; const char *varname;
// Search in parent scope which is possible to reference from lambda // Search in parent scope which is possible to reference from lambda
current_funccal = current_funccal->func->uf_scoped; current_funccal = current_funccal->fc_func->uf_scoped;
while (current_funccal) { while (current_funccal) {
hashtab_T *ht = find_var_ht(name, namelen, &varname); hashtab_T *ht = find_var_ht(name, namelen, &varname);
if (ht != NULL && *varname != NUL) { if (ht != NULL && *varname != NUL) {
@ -3721,10 +3721,10 @@ dictitem_T *find_var_in_scoped_ht(const char *name, const size_t namelen, int no
break; break;
} }
} }
if (current_funccal == current_funccal->func->uf_scoped) { if (current_funccal == current_funccal->fc_func->uf_scoped) {
break; break;
} }
current_funccal = current_funccal->func->uf_scoped; current_funccal = current_funccal->fc_func->uf_scoped;
} }
current_funccal = old_current_funccal; current_funccal = old_current_funccal;
@ -3735,11 +3735,11 @@ dictitem_T *find_var_in_scoped_ht(const char *name, const size_t namelen, int no
bool set_ref_in_previous_funccal(int copyID) bool set_ref_in_previous_funccal(int copyID)
{ {
for (funccall_T *fc = previous_funccal; fc != NULL; for (funccall_T *fc = previous_funccal; fc != NULL;
fc = fc->caller) { fc = fc->fc_caller) {
fc->fc_copyID = copyID + 1; fc->fc_copyID = copyID + 1;
if (set_ref_in_ht(&fc->l_vars.dv_hashtab, copyID + 1, NULL) if (set_ref_in_ht(&fc->fc_l_vars.dv_hashtab, copyID + 1, NULL)
|| set_ref_in_ht(&fc->l_avars.dv_hashtab, copyID + 1, NULL) || set_ref_in_ht(&fc->fc_l_avars.dv_hashtab, copyID + 1, NULL)
|| set_ref_in_list(&fc->l_varlist, copyID + 1, NULL)) { || set_ref_in_list(&fc->fc_l_varlist, copyID + 1, NULL)) {
return true; return true;
} }
} }
@ -3750,10 +3750,10 @@ static bool set_ref_in_funccal(funccall_T *fc, int copyID)
{ {
if (fc->fc_copyID != copyID) { if (fc->fc_copyID != copyID) {
fc->fc_copyID = copyID; fc->fc_copyID = copyID;
if (set_ref_in_ht(&fc->l_vars.dv_hashtab, copyID, NULL) if (set_ref_in_ht(&fc->fc_l_vars.dv_hashtab, copyID, NULL)
|| set_ref_in_ht(&fc->l_avars.dv_hashtab, copyID, NULL) || set_ref_in_ht(&fc->fc_l_avars.dv_hashtab, copyID, NULL)
|| set_ref_in_list(&fc->l_varlist, copyID, NULL) || set_ref_in_list(&fc->fc_l_varlist, copyID, NULL)
|| set_ref_in_func(NULL, fc->func, copyID)) { || set_ref_in_func(NULL, fc->fc_func, copyID)) {
return true; return true;
} }
} }
@ -3764,7 +3764,7 @@ static bool set_ref_in_funccal(funccall_T *fc, int copyID)
bool set_ref_in_call_stack(int copyID) bool set_ref_in_call_stack(int copyID)
{ {
for (funccall_T *fc = current_funccal; fc != NULL; for (funccall_T *fc = current_funccal; fc != NULL;
fc = fc->caller) { fc = fc->fc_caller) {
if (set_ref_in_funccal(fc, copyID)) { if (set_ref_in_funccal(fc, copyID)) {
return true; return true;
} }
@ -3774,7 +3774,7 @@ bool set_ref_in_call_stack(int copyID)
for (funccal_entry_T *entry = funccal_stack; entry != NULL; for (funccal_entry_T *entry = funccal_stack; entry != NULL;
entry = entry->next) { entry = entry->next) {
for (funccall_T *fc = entry->top_funccal; fc != NULL; for (funccall_T *fc = entry->top_funccal; fc != NULL;
fc = fc->caller) { fc = fc->fc_caller) {
if (set_ref_in_funccal(fc, copyID)) { if (set_ref_in_funccal(fc, copyID)) {
return true; return true;
} }
@ -3839,7 +3839,7 @@ bool set_ref_in_func(char *name, ufunc_T *fp_in, int copyID)
fp = find_func(fname); fp = find_func(fname);
} }
if (fp != NULL) { if (fp != NULL) {
for (fc = fp->uf_scoped; fc != NULL; fc = fc->func->uf_scoped) { for (fc = fp->uf_scoped; fc != NULL; fc = fc->fc_func->uf_scoped) {
abort = abort || set_ref_in_funccal(fc, copyID); abort = abort || set_ref_in_funccal(fc, copyID);
} }
} }

24
src/nvim/profile.c
View File

@ -513,8 +513,8 @@ void prof_child_enter(proftime_T *tm)
{ {
funccall_T *fc = get_current_funccal(); funccall_T *fc = get_current_funccal();
if (fc != NULL && fc->func->uf_profiling) { if (fc != NULL && fc->fc_func->uf_profiling) {
fc->prof_child = profile_start(); fc->fc_prof_child = profile_start();
} }
script_prof_save(tm); script_prof_save(tm);
@ -528,14 +528,14 @@ void prof_child_exit(proftime_T *tm)
{ {
funccall_T *fc = get_current_funccal(); funccall_T *fc = get_current_funccal();
if (fc != NULL && fc->func->uf_profiling) { if (fc != NULL && fc->fc_func->uf_profiling) {
fc->prof_child = profile_end(fc->prof_child); fc->fc_prof_child = profile_end(fc->fc_prof_child);
// don't count waiting time // don't count waiting time
fc->prof_child = profile_sub_wait(*tm, fc->prof_child); fc->fc_prof_child = profile_sub_wait(*tm, fc->fc_prof_child);
fc->func->uf_tm_children = fc->fc_func->uf_tm_children =
profile_add(fc->func->uf_tm_children, fc->prof_child); profile_add(fc->fc_func->uf_tm_children, fc->fc_prof_child);
fc->func->uf_tml_children = fc->fc_func->uf_tml_children =
profile_add(fc->func->uf_tml_children, fc->prof_child); profile_add(fc->fc_func->uf_tml_children, fc->fc_prof_child);
} }
script_prof_restore(tm); script_prof_restore(tm);
} }
@ -547,7 +547,7 @@ void prof_child_exit(proftime_T *tm)
void func_line_start(void *cookie) void func_line_start(void *cookie)
{ {
funccall_T *fcp = (funccall_T *)cookie; funccall_T *fcp = (funccall_T *)cookie;
ufunc_T *fp = fcp->func; ufunc_T *fp = fcp->fc_func;
if (fp->uf_profiling && SOURCING_LNUM >= 1 && SOURCING_LNUM <= fp->uf_lines.ga_len) { if (fp->uf_profiling && SOURCING_LNUM >= 1 && SOURCING_LNUM <= fp->uf_lines.ga_len) {
fp->uf_tml_idx = SOURCING_LNUM - 1; fp->uf_tml_idx = SOURCING_LNUM - 1;
@ -566,7 +566,7 @@ void func_line_start(void *cookie)
void func_line_exec(void *cookie) void func_line_exec(void *cookie)
{ {
funccall_T *fcp = (funccall_T *)cookie; funccall_T *fcp = (funccall_T *)cookie;
ufunc_T *fp = fcp->func; ufunc_T *fp = fcp->fc_func;
if (fp->uf_profiling && fp->uf_tml_idx >= 0) { if (fp->uf_profiling && fp->uf_tml_idx >= 0) {
fp->uf_tml_execed = true; fp->uf_tml_execed = true;
@ -577,7 +577,7 @@ void func_line_exec(void *cookie)
void func_line_end(void *cookie) void func_line_end(void *cookie)
{ {
funccall_T *fcp = (funccall_T *)cookie; funccall_T *fcp = (funccall_T *)cookie;
ufunc_T *fp = fcp->func; ufunc_T *fp = fcp->fc_func;
if (fp->uf_profiling && fp->uf_tml_idx >= 0) { if (fp->uf_profiling && fp->uf_tml_idx >= 0) {
if (fp->uf_tml_execed) { if (fp->uf_tml_execed) {