Mirrors/fish-shell
2
0
Fork 0
mirror of https://github.com/fish-shell/fish-shell synced 2024-12-27 05:13:10 +00:00
Code Issues Projects Releases Packages Wiki Activity

restyle function module to match project style

Browse source 
Reduces lint errors from 39 to 27 (-31%). Line count from 619 to 498 (-20%).

Another step in resolving issue #2902.
This commit is contained in:
Kurtis Rader 2016-04-30 20:31:02 -07:00
parent 075811e588
commit d3f155d895
2 changed files with 220 additions and 341 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

360
src/function.cpp
View file

@ -1,96 +1,76 @@
/** \file function.c
Prototypes for functions for storing and retrieving function
information. These functions also take care of autoloading
functions in the $fish_function_path. Actual function evaluation
is taken care of by the parser and to some degree the builtin
handling library.
*/
// Functions for storing and retrieving function information. These functions also take care of
// autoloading functions in the $fish_function_path. Actual function evaluation is taken care of by
// the parser and to some degree the builtin handling library.
//
// IWYU pragma: no_include <type_traits>
#include <wchar.h>
#include <pthread.h>
#include <map>
#include <set>
#include <dirent.h>
#include <pthread.h>
#include <stddef.h>
#include <wchar.h>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <utility>
#include <memory>
#include "wutil.h" // IWYU pragma: keep
#include "fallback.h" // IWYU pragma: keep
#include "autoload.h"
#include "function.h"
#include "common.h"
#include "intern.h"
#include "event.h"
#include "reader.h"
#include "parser_keywords.h"
#include "env.h"
#include "event.h"
#include "fallback.h" // IWYU pragma: keep
#include "function.h"
#include "intern.h"
#include "parser_keywords.h"
#include "reader.h"
#include "wutil.h" // IWYU pragma: keep
/**
Table containing all functions
*/
/// Table containing all functions.
typedef std::map<wcstring, function_info_t> function_map_t;
static function_map_t loaded_functions;
/**
Functions that shouldn't be autoloaded (anymore).
*/
/// Functions that shouldn't be autoloaded (anymore).
static std::set<wcstring> function_tombstones;
/* Lock for functions */
/// Lock for functions.
static pthread_mutex_t functions_lock;
/* Autoloader for functions */
class function_autoload_t : public autoload_t
{
public:
/// Autoloader for functions.
class function_autoload_t : public autoload_t {
public:
function_autoload_t();
virtual void command_removed(const wcstring &cmd);
};
static function_autoload_t function_autoloader;
/** Constructor */
function_autoload_t::function_autoload_t() : autoload_t(L"fish_function_path", NULL, 0)
{
}
/// Constructor
function_autoload_t::function_autoload_t() : autoload_t(L"fish_function_path", NULL, 0) {}
static bool function_remove_ignore_autoload(const wcstring &name, bool tombstone = true);
/** Callback when an autoloaded function is removed */
void function_autoload_t::command_removed(const wcstring &cmd)
{
/// Callback when an autoloaded function is removed.
void function_autoload_t::command_removed(const wcstring &cmd) {
function_remove_ignore_autoload(cmd, false);
}
/**
Kludgy flag set by the load function in order to tell function_add
that the function being defined is autoloaded. There should be a
better way to do this...
*/
/// Kludgy flag set by the load function in order to tell function_add that the function being
/// defined is autoloaded. There should be a better way to do this...
static bool is_autoload = false;
/**
Make sure that if the specified function is a dynamically loaded
function, it has been fully loaded.
*/
static int load(const wcstring &name)
{
/// Make sure that if the specified function is a dynamically loaded function, it has been fully
/// loaded.
static int load(const wcstring &name) {
ASSERT_IS_MAIN_THREAD();
scoped_lock lock(functions_lock);
bool was_autoload = is_autoload;
int res;
bool no_more_autoload = function_tombstones.count(name) > 0;
if (no_more_autoload)
return 0;
if (no_more_autoload) return 0;
function_map_t::iterator iter = loaded_functions.find(name);
if (iter != loaded_functions.end() && !iter->second.is_autoload)
{
/* We have a non-autoload version already */
if (iter != loaded_functions.end() && !iter->second.is_autoload) {
// We have a non-autoload version already.
return 0;
}
@ -100,41 +80,31 @@ static int load(const wcstring &name)
return res;
}
/**
Insert a list of all dynamically loaded functions into the
specified list.
*/
static void autoload_names(std::set<wcstring> &names, int get_hidden)
{
/// Insert a list of all dynamically loaded functions into the specified list.
static void autoload_names(std::set<wcstring> &names, int get_hidden) {
size_t i;
const env_var_t path_var_wstr = env_get_string(L"fish_function_path");
if (path_var_wstr.missing())
return;
const env_var_t path_var_wstr = env_get_string(L"fish_function_path");
if (path_var_wstr.missing()) return;
const wchar_t *path_var = path_var_wstr.c_str();
wcstring_list_t path_list;
tokenize_variable_array(path_var, path_list);
for (i=0; i<path_list.size(); i++)
{
for (i = 0; i < path_list.size(); i++) {
const wcstring &ndir_str = path_list.at(i);
const wchar_t *ndir = (wchar_t *)ndir_str.c_str();
DIR *dir = wopendir(ndir);
if (!dir)
continue;
if (!dir) continue;
wcstring name;
while (wreaddir(dir, name))
{
while (wreaddir(dir, name)) {
const wchar_t *fn = name.c_str();
const wchar_t *suffix;
if (!get_hidden && fn[0] == L'_')
continue;
if (!get_hidden && fn[0] == L'_') continue;
suffix = wcsrchr(fn, L'.');
if (suffix && (wcscmp(suffix, L".fish") == 0))
{
if (suffix && (wcscmp(suffix, L".fish") == 0)) {
wcstring name(fn, suffix - fn);
names.insert(name);
}
@ -143,236 +113,202 @@ static void autoload_names(std::set<wcstring> &names, int get_hidden)
}
}
void function_init()
{
/* PCA: This recursive lock was introduced early in my work. I would like to make this a non-recursive lock but I haven't fully investigated all the call paths (for autoloading functions, etc.) */
void function_init() {
// PCA: This recursive lock was introduced early in my work. I would like to make this a
// non-recursive lock but I haven't fully investigated all the call paths (for autoloading
// functions, etc.).
pthread_mutexattr_t a;
VOMIT_ON_FAILURE(pthread_mutexattr_init(&a));
VOMIT_ON_FAILURE(pthread_mutexattr_settype(&a,PTHREAD_MUTEX_RECURSIVE));
VOMIT_ON_FAILURE(pthread_mutexattr_settype(&a, PTHREAD_MUTEX_RECURSIVE));
VOMIT_ON_FAILURE(pthread_mutex_init(&functions_lock, &a));
VOMIT_ON_FAILURE(pthread_mutexattr_destroy(&a));
}
static std::map<wcstring,env_var_t> snapshot_vars(const wcstring_list_t &vars)
{
std::map<wcstring,env_var_t> result;
for (wcstring_list_t::const_iterator it = vars.begin(), end = vars.end(); it != end; ++it)
{
static std::map<wcstring, env_var_t> snapshot_vars(const wcstring_list_t &vars) {
std::map<wcstring, env_var_t> result;
for (wcstring_list_t::const_iterator it = vars.begin(), end = vars.end(); it != end; ++it) {
result.insert(std::make_pair(*it, env_get_string(*it)));
}
return result;
}
function_info_t::function_info_t(const function_data_t &data, const wchar_t *filename, int def_offset, bool autoload) :
definition(data.definition),
description(data.description),
definition_file(intern(filename)),
definition_offset(def_offset),
named_arguments(data.named_arguments),
inherit_vars(snapshot_vars(data.inherit_vars)),
is_autoload(autoload),
shadows(data.shadows)
{
}
function_info_t::function_info_t(const function_data_t &data, const wchar_t *filename,
int def_offset, bool autoload)
: definition(data.definition),
description(data.description),
definition_file(intern(filename)),
definition_offset(def_offset),
named_arguments(data.named_arguments),
inherit_vars(snapshot_vars(data.inherit_vars)),
is_autoload(autoload),
shadows(data.shadows) {}
function_info_t::function_info_t(const function_info_t &data, const wchar_t *filename, int def_offset, bool autoload) :
definition(data.definition),
description(data.description),
definition_file(intern(filename)),
definition_offset(def_offset),
named_arguments(data.named_arguments),
inherit_vars(data.inherit_vars),
is_autoload(autoload),
shadows(data.shadows)
{
}
function_info_t::function_info_t(const function_info_t &data, const wchar_t *filename,
int def_offset, bool autoload)
: definition(data.definition),
description(data.description),
definition_file(intern(filename)),
definition_offset(def_offset),
named_arguments(data.named_arguments),
inherit_vars(data.inherit_vars),
is_autoload(autoload),
shadows(data.shadows) {}
void function_add(const function_data_t &data, const parser_t &parser, int definition_line_offset)
{
void function_add(const function_data_t &data, const parser_t &parser, int definition_line_offset) {
ASSERT_IS_MAIN_THREAD();
CHECK(! data.name.empty(),);
CHECK(data.definition,);
CHECK(!data.name.empty(), );
CHECK(data.definition, );
scoped_lock lock(functions_lock);
/* Remove the old function */
// Remove the old function.
function_remove(data.name);
/* Create and store a new function */
// Create and store a new function.
const wchar_t *filename = reader_current_filename();
const function_map_t::value_type new_pair(data.name, function_info_t(data, filename, definition_line_offset, is_autoload));
const function_map_t::value_type new_pair(
data.name, function_info_t(data, filename, definition_line_offset, is_autoload));
loaded_functions.insert(new_pair);
/* Add event handlers */
for (std::vector<event_t>::const_iterator iter = data.events.begin(); iter != data.events.end(); ++iter)
{
// Add event handlers.
for (std::vector<event_t>::const_iterator iter = data.events.begin(); iter != data.events.end();
++iter) {
event_add_handler(*iter);
}
}
int function_exists(const wcstring &cmd)
{
if (parser_keywords_is_reserved(cmd))
return 0;
int function_exists(const wcstring &cmd) {
if (parser_keywords_is_reserved(cmd)) return 0;
scoped_lock lock(functions_lock);
load(cmd);
return loaded_functions.find(cmd) != loaded_functions.end();
}
void function_load(const wcstring &cmd)
{
if (! parser_keywords_is_reserved(cmd))
{
void function_load(const wcstring &cmd) {
if (!parser_keywords_is_reserved(cmd)) {
scoped_lock lock(functions_lock);
load(cmd);
}
}
int function_exists_no_autoload(const wcstring &cmd, const env_vars_snapshot_t &vars)
{
if (parser_keywords_is_reserved(cmd))
return 0;
int function_exists_no_autoload(const wcstring &cmd, const env_vars_snapshot_t &vars) {
if (parser_keywords_is_reserved(cmd)) return 0;
scoped_lock lock(functions_lock);
return loaded_functions.find(cmd) != loaded_functions.end() || function_autoloader.can_load(cmd, vars);
return loaded_functions.find(cmd) != loaded_functions.end() ||
function_autoloader.can_load(cmd, vars);
}
static bool function_remove_ignore_autoload(const wcstring &name, bool tombstone)
{
// Note: the lock may be held at this point, but is recursive
static bool function_remove_ignore_autoload(const wcstring &name, bool tombstone) {
// Note: the lock may be held at this point, but is recursive.
scoped_lock lock(functions_lock);
function_map_t::iterator iter = loaded_functions.find(name);
// not found. not erasing.
if (iter == loaded_functions.end())
return false;
// Not found. Not erasing.
if (iter == loaded_functions.end()) return false;
// removing an auto-loaded function. prevent it from being
// auto-reloaded.
if (iter->second.is_autoload && tombstone)
function_tombstones.insert(name);
// Removing an auto-loaded function. Prevent it from being auto-reloaded.
if (iter->second.is_autoload && tombstone) function_tombstones.insert(name);
loaded_functions.erase(iter);
event_t ev(EVENT_ANY);
ev.function_name=name;
ev.function_name = name;
event_remove(ev);
return true;
}
void function_remove(const wcstring &name)
{
if (function_remove_ignore_autoload(name))
function_autoloader.unload(name);
void function_remove(const wcstring &name) {
if (function_remove_ignore_autoload(name)) function_autoloader.unload(name);
}
static const function_info_t *function_get(const wcstring &name)
{
// The caller must lock the functions_lock before calling this; however our mutex is currently recursive, so trylock will never fail
// We need a way to correctly check if a lock is locked (or better yet, make our lock non-recursive)
//ASSERT_IS_LOCKED(functions_lock);
static const function_info_t *function_get(const wcstring &name) {
// The caller must lock the functions_lock before calling this; however our mutex is currently
// recursive, so trylock will never fail. We need a way to correctly check if a lock is locked
// (or better yet, make our lock non-recursive).
// ASSERT_IS_LOCKED(functions_lock);
function_map_t::iterator iter = loaded_functions.find(name);
if (iter == loaded_functions.end())
{
if (iter == loaded_functions.end()) {
return NULL;
}
else
{
} else {
return &iter->second;
}
}
bool function_get_definition(const wcstring &name, wcstring *out_definition)
{
bool function_get_definition(const wcstring &name, wcstring *out_definition) {
scoped_lock lock(functions_lock);
const function_info_t *func = function_get(name);
if (func && out_definition)
{
if (func && out_definition) {
out_definition->assign(func->definition);
}
return func != NULL;
}
wcstring_list_t function_get_named_arguments(const wcstring &name)
{
wcstring_list_t function_get_named_arguments(const wcstring &name) {
scoped_lock lock(functions_lock);
const function_info_t *func = function_get(name);
return func ? func->named_arguments : wcstring_list_t();
}
std::map<wcstring,env_var_t> function_get_inherit_vars(const wcstring &name)
{
std::map<wcstring, env_var_t> function_get_inherit_vars(const wcstring &name) {
scoped_lock lock(functions_lock);
const function_info_t *func = function_get(name);
return func ? func->inherit_vars : std::map<wcstring,env_var_t>();
return func ? func->inherit_vars : std::map<wcstring, env_var_t>();
}
int function_get_shadows(const wcstring &name)
{
int function_get_shadows(const wcstring &name) {
scoped_lock lock(functions_lock);
const function_info_t *func = function_get(name);
return func ? func->shadows : false;
}
bool function_get_desc(const wcstring &name, wcstring *out_desc)
{
/* Empty length string goes to NULL */
bool function_get_desc(const wcstring &name, wcstring *out_desc) {
// Empty length string goes to NULL.
scoped_lock lock(functions_lock);
const function_info_t *func = function_get(name);
if (out_desc && func && ! func->description.empty())
{
if (out_desc && func && !func->description.empty()) {
out_desc->assign(_(func->description.c_str()));
return true;
}
else
{
} else {
return false;
}
}
void function_set_desc(const wcstring &name, const wcstring &desc)
{
void function_set_desc(const wcstring &name, const wcstring &desc) {
load(name);
scoped_lock lock(functions_lock);
function_map_t::iterator iter = loaded_functions.find(name);
if (iter != loaded_functions.end())
{
if (iter != loaded_functions.end()) {
iter->second.description = desc;
}
}
bool function_copy(const wcstring &name, const wcstring &new_name)
{
bool function_copy(const wcstring &name, const wcstring &new_name) {
bool result = false;
scoped_lock lock(functions_lock);
function_map_t::const_iterator iter = loaded_functions.find(name);
if (iter != loaded_functions.end())
{
// This new instance of the function shouldn't be tied to the definition file of the original, so pass NULL filename, etc.
const function_map_t::value_type new_pair(new_name, function_info_t(iter->second, NULL, 0, false));
if (iter != loaded_functions.end()) {
// This new instance of the function shouldn't be tied to the definition file of the
// original, so pass NULL filename, etc.
const function_map_t::value_type new_pair(new_name,
function_info_t(iter->second, NULL, 0, false));
loaded_functions.insert(new_pair);
result = true;
}
return result;
}
wcstring_list_t function_get_names(int get_hidden)
{
wcstring_list_t function_get_names(int get_hidden) {
std::set<wcstring> names;
scoped_lock lock(functions_lock);
autoload_names(names, get_hidden);
function_map_t::const_iterator iter;
for (iter = loaded_functions.begin(); iter != loaded_functions.end(); ++iter)
{
for (iter = loaded_functions.begin(); iter != loaded_functions.end(); ++iter) {
const wcstring &name = iter->first;
/* Maybe skip hidden */
if (! get_hidden)
{
// Maybe skip hidden.
if (!get_hidden) {
if (name.empty() || name.at(0) == L'_') continue;
}
names.insert(name);
@ -380,46 +316,40 @@ wcstring_list_t function_get_names(int get_hidden)
return wcstring_list_t(names.begin(), names.end());
}
const wchar_t *function_get_definition_file(const wcstring &name)
{
const wchar_t *function_get_definition_file(const wcstring &name) {
scoped_lock lock(functions_lock);
const function_info_t *func = function_get(name);
return func ? func->definition_file : NULL;
}
int function_get_definition_offset(const wcstring &name)
{
int function_get_definition_offset(const wcstring &name) {
scoped_lock lock(functions_lock);
const function_info_t *func = function_get(name);
return func ? func->definition_offset : -1;
}
void function_prepare_environment(const wcstring &name, const wchar_t * const * argv, const std::map<wcstring, env_var_t> &inherited_vars)
{
/* Three components of the environment:
1. argv
2. named arguments
3. inherited variables
*/
void function_prepare_environment(const wcstring &name, const wchar_t *const *argv,
const std::map<wcstring, env_var_t> &inherited_vars) {
// Three components of the environment:
// 1. argv
// 2. named arguments
// 3. inherited variables
env_set_argv(argv);
const wcstring_list_t named_arguments = function_get_named_arguments(name);
if (! named_arguments.empty())
{
const wchar_t * const *arg;
if (!named_arguments.empty()) {
const wchar_t *const *arg;
size_t i;
for (i=0, arg=argv; i < named_arguments.size(); i++)
{
for (i = 0, arg = argv; i < named_arguments.size(); i++) {
env_set(named_arguments.at(i).c_str(), *arg, ENV_LOCAL | ENV_USER);
if (*arg)
arg++;
if (*arg) arg++;
}
}
for (std::map<wcstring,env_var_t>::const_iterator it = inherited_vars.begin(), end = inherited_vars.end(); it != end; ++it)
{
for (std::map<wcstring, env_var_t>::const_iterator it = inherited_vars.begin(),
end = inherited_vars.end();
it != end; ++it) {
env_set(it->first, it->second.missing() ? NULL : it->second.c_str(), ENV_LOCAL | ENV_USER);
}
}

201
src/function.h
View file

@ -1,194 +1,143 @@
/** \file function.h
Prototypes for functions for storing and retrieving function
information. These functions also take care of autoloading
functions in the $fish_function_path. Actual function evaluation
is taken care of by the parser and to some degree the builtin
handling library.
*/
// Prototypes for functions for storing and retrieving function information. These functions also
// take care of autoloading functions in the $fish_function_path. Actual function evaluation is
// taken care of by the parser and to some degree the builtin handling library.
#ifndef FISH_FUNCTION_H
#define FISH_FUNCTION_H
#include <vector>
#include <map>
#include <stdbool.h>
#include <map>
#include <vector>
#include "common.h"
#include "event.h"
#include "env.h"
#include "event.h"
class parser_t;
/**
Structure describing a function. This is used by the parser to
store data on a function while parsing it. It is not used
internally to store functions, the function_internal_data_t
structure is used for that purpose. Parhaps these two should be
merged.
*/
struct function_data_t
{
/**
Name of function
*/
/// Structure describing a function. This is used by the parser to store data on a function while
/// parsing it. It is not used internally to store functions, the function_internal_data_t structure
/// is used for that purpose. Parhaps these two should be merged.
struct function_data_t {
/// Name of function.
wcstring name;
/**
Description of function
*/
/// Description of function.
wcstring description;
/**
Function definition
*/
/// Function definition.
const wchar_t *definition;
/**
List of all event handlers for this function
*/
/// List of all event handlers for this function.
std::vector<event_t> events;
/**
List of all named arguments for this function
*/
/// List of all named arguments for this function.
wcstring_list_t named_arguments;
/**
List of all variables that are inherited from the function definition scope.
The variable values are snapshotted when function_add() is called.
*/
/// List of all variables that are inherited from the function definition scope. The variable
/// values are snapshotted when function_add() is called.
wcstring_list_t inherit_vars;
/**
Set to non-zero if invoking this function shadows the variables
of the underlying function.
*/
/// Set to non-zero if invoking this function shadows the variables of the underlying function.
int shadows;
};
class function_info_t
{
public:
/** Constructs relevant information from the function_data */
function_info_t(const function_data_t &data, const wchar_t *filename, int def_offset, bool autoload);
class function_info_t {
public:
/// Constructs relevant information from the function_data.
function_info_t(const function_data_t &data, const wchar_t *filename, int def_offset,
bool autoload);
/** Used by function_copy */
function_info_t(const function_info_t &data, const wchar_t *filename, int def_offset, bool autoload);
/// Used by function_copy.
function_info_t(const function_info_t &data, const wchar_t *filename, int def_offset,
bool autoload);
/** Function definition */
/// Function definition.
const wcstring definition;
/** Function description. Only the description may be changed after the function is created. */
/// Function description. Only the description may be changed after the function is created.
wcstring description;
/** File where this function was defined (intern'd string) */
const wchar_t * const definition_file;
/// File where this function was defined (intern'd string).
const wchar_t *const definition_file;
/** Line where definition started */
/// Line where definition started.
const int definition_offset;
/** List of all named arguments for this function */
/// List of all named arguments for this function.
const wcstring_list_t named_arguments;
/** Mapping of all variables that were inherited from the function definition scope to their values */
const std::map<wcstring,env_var_t> inherit_vars;
/// Mapping of all variables that were inherited from the function definition scope to their
/// values.
const std::map<wcstring, env_var_t> inherit_vars;
/** Flag for specifying that this function was automatically loaded */
/// Flag for specifying that this function was automatically loaded.
const bool is_autoload;
/** Set to true if invoking this function shadows the variables of the underlying function. */
/// Set to true if invoking this function shadows the variables of the underlying function.
const bool shadows;
};
/**
Initialize function data
*/
/// Initialize function data.
void function_init();
/** Add a function. definition_line_offset is the line number of the function's definition within its source file */
void function_add(const function_data_t &data, const parser_t &parser, int definition_line_offset = 0);
/// Add a function. definition_line_offset is the line number of the function's definition within
/// its source file.
void function_add(const function_data_t &data, const parser_t &parser,
int definition_line_offset = 0);
/**
Remove the function with the specified name.
*/
/// Remove the function with the specified name.
void function_remove(const wcstring &name);
/**
Returns by reference the definition of the function with the name \c name.
Returns true if successful, false if no function with the given name exists.
*/
/// Returns by reference the definition of the function with the name \c name. Returns true if
/// successful, false if no function with the given name exists.
bool function_get_definition(const wcstring &name, wcstring *out_definition);
/**
Returns by reference the description of the function with the name \c name.
Returns true if the function exists and has a nonempty description, false if it does not.
*/
/// Returns by reference the description of the function with the name \c name. Returns true if the
/// function exists and has a nonempty description, false if it does not.
bool function_get_desc(const wcstring &name, wcstring *out_desc);
/**
Sets the description of the function with the name \c name.
*/
/// Sets the description of the function with the name \c name.
void function_set_desc(const wcstring &name, const wcstring &desc);
/**
Returns true if the function with the name name exists.
*/
/// Returns true if the function with the name name exists.
int function_exists(const wcstring &name);
/** Attempts to load a function if not yet loaded. This is used by the completion machinery. */
/// Attempts to load a function if not yet loaded. This is used by the completion machinery.
void function_load(const wcstring &name);
/**
Returns true if the function with the name name exists, without triggering autoload.
*/
/// Returns true if the function with the name name exists, without triggering autoload.
int function_exists_no_autoload(const wcstring &name, const env_vars_snapshot_t &vars);
/**
Returns all function names.
\param get_hidden whether to include hidden functions, i.e. ones starting with an underscore
*/
/// Returns all function names.
///
/// \param get_hidden whether to include hidden functions, i.e. ones starting with an underscore.
wcstring_list_t function_get_names(int get_hidden);
/**
Returns tha absolute path of the file where the specified function
was defined. Returns 0 if the file was defined on the commandline.
This function does not autoload functions, it will only work on
functions that have already been defined.
This returns an intern'd string.
*/
/// Returns tha absolute path of the file where the specified function was defined. Returns 0 if the
/// file was defined on the commandline.
///
/// This function does not autoload functions, it will only work on functions that have already been
/// defined.
///
/// This returns an intern'd string.
const wchar_t *function_get_definition_file(const wcstring &name);
/**
Returns the linenumber where the definition of the specified
function started.
This function does not autoload functions, it will only work on
functions that have already been defined.
*/
/// Returns the linenumber where the definition of the specified function started.
///
/// This function does not autoload functions, it will only work on functions that have already been
/// defined.
int function_get_definition_offset(const wcstring &name);
/**
Returns a list of all named arguments of the specified function.
*/
/// Returns a list of all named arguments of the specified function.
wcstring_list_t function_get_named_arguments(const wcstring &name);
/**
Returns a mapping of all variables of the specified function that were inherited
from the scope of the function definition to their values.
*/
std::map<wcstring,env_var_t> function_get_inherit_vars(const wcstring &name);
/// Returns a mapping of all variables of the specified function that were inherited from the scope
/// of the function definition to their values.
std::map<wcstring, env_var_t> function_get_inherit_vars(const wcstring &name);
/**
Creates a new function using the same definition as the specified function.
Returns true if copy is successful.
*/
/// Creates a new function using the same definition as the specified function. Returns true if copy
/// is successful.
bool function_copy(const wcstring &name, const wcstring &new_name);
/**
Returns whether this function shadows variables of the underlying function
*/
/// Returns whether this function shadows variables of the underlying function.
int function_get_shadows(const wcstring &name);
/** Prepares the environment for executing a function.
*/
void function_prepare_environment(const wcstring &name, const wchar_t * const * argv, const std::map<wcstring, env_var_t> &inherited_vars);
/// Prepares the environment for executing a function.
void function_prepare_environment(const wcstring &name, const wchar_t *const *argv,
const std::map<wcstring, env_var_t> &inherited_vars);
#endif