fish-shell/function.cpp

/** \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.
*/

#include "config.h"

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <wchar.h>
#include <unistd.h>
#include <termios.h>
#include <signal.h>
#include <pthread.h>
#include <errno.h>
#include <map>
#include <set>

#include "wutil.h"
#include "fallback.h"
#include "util.h"

#include "function.h"
#include "proc.h"
#include "parser.h"
#include "common.h"
#include "intern.h"
#include "event.h"
#include "reader.h"
#include "parse_util.h"
#include "parser_keywords.h"
#include "env.h"
#include "expand.h"
#include "builtin_scripts.h"

/**
   Table containing all functions
*/
typedef std::map<wcstring, shared_ptr<function_info_t> > function_map_t;
static function_map_t loaded_functions;

/* Lock for functions */
static pthread_mutex_t functions_lock;

/* 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",
                                                        internal_function_scripts,
                                                        sizeof internal_function_scripts / sizeof *internal_function_scripts)
{
}

/** Removes a function from our internal table, returning true if it was found and false if not */
static bool function_remove_ignore_autoload(const wcstring &name);

/** Callback when an autoloaded function is removed */
void function_autoload_t::command_removed(const wcstring &cmd) {
    function_remove_ignore_autoload(cmd);
}

/* Helper macro for vomiting */
#define VOMIT_ON_FAILURE(a) do { if (0 != (a)) { int err = errno; fprintf(stderr, "%s failed on line %d in file %s: %d (%s)\n", #a, __LINE__, __FILE__, err, strerror(err)); abort(); }} while (0)

/**
   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 )
{
    ASSERT_IS_MAIN_THREAD();
    scoped_lock lock(functions_lock);
	bool was_autoload = is_autoload;
	int res;
    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 */
		return 0;
    }
	
	is_autoload = true;	
	res = function_autoloader.load( name, true );
	is_autoload = was_autoload;
	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 )
{
	size_t i;
	
	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++ )
	{
        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;
		
		wcstring name;
		while (wreaddir(dir, name))
		{
			const wchar_t *fn = name.c_str();
			const wchar_t *suffix;
			if( !get_hidden && fn[0] == L'_' )
				continue;
			
            suffix = wcsrchr( fn, L'.' );
			if( suffix && (wcscmp( suffix, L".fish" ) == 0 ) )
			{
                wcstring name(fn, suffix - fn);
                names.insert(name);
			}
		}				
		closedir(dir);
	}
}

void function_init()
{
    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_mutex_init(&functions_lock, &a));
    VOMIT_ON_FAILURE(pthread_mutexattr_destroy(&a));
}

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),
    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),
    is_autoload(autoload),
    shadows(data.shadows)
{
}

void function_add( const function_data_t &data, const parser_t &parser )
{
    ASSERT_IS_MAIN_THREAD();
    
	CHECK( ! data.name.empty(), );
	CHECK( data.definition, );
	scoped_lock lock(functions_lock);
    
    /* Remove the old function */
	function_remove( data.name );
    
    /* Create a new function */
    const wchar_t *filename = reader_current_filename();
    int def_offset = parse_util_lineno( parser.get_buffer(), parser.current_block->tok_pos )-1;
    function_info_t *new_info = new function_info_t(data, filename, def_offset, is_autoload);
    
    /* Store it in the loaded_functions map */
    loaded_functions[data.name].reset(new_info);
	
    /* 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;
    scoped_lock lock(functions_lock);
    load(cmd);
    return loaded_functions.find(cmd) != loaded_functions.end();            
}

int function_exists_no_autoload( const wcstring &cmd, const env_vars &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);            
}

static bool function_remove_ignore_autoload(const wcstring &name)
{
    scoped_lock lock(functions_lock);
    bool erased = (loaded_functions.erase(name) > 0);
	
	if (erased) {
        event_t ev(EVENT_ANY);
        ev.function_name=name;	
        event_remove( &ev );
    }
    return erased;

}

void function_remove( const wcstring &name )
{
    if (function_remove_ignore_autoload(name))
        function_autoloader.unload( name );
}

shared_ptr<function_info_t> function_get(const wcstring &name)
{
    scoped_lock lock(functions_lock);
    function_map_t::iterator iter = loaded_functions.find(name);
    if (iter == loaded_functions.end()) {
        return shared_ptr<function_info_t>();
    } else {
        return iter->second;
    }
}
	
const wchar_t *function_get_definition( const wcstring &name )
{
    shared_ptr<function_info_t> func = function_get(name);
    return func ? func->definition.c_str() : NULL;
}

wcstring_list_t function_get_named_arguments( const wcstring &name )
{
    shared_ptr<function_info_t> func = function_get(name);
    return func ? func->named_arguments : wcstring_list_t();
}

int function_get_shadows( const wcstring &name )
{
    shared_ptr<function_info_t> func = function_get(name);
    return func ? func->shadows : false;
}

	
const wchar_t *function_get_desc( const wcstring &name )
{
    /* Empty length string goes to NULL */
    shared_ptr<function_info_t> func = function_get(name);
    if (func && func->description.size()) {
        return _(func->description.c_str());
    } else {
        return NULL;
    }
}

void function_set_desc( const wcstring &name, const wcstring &desc )
{
	load( name );
    shared_ptr<function_info_t> func = function_get(name);
    if (func) func->description = desc;
}

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()) {
        shared_ptr<function_info_t> &new_info = loaded_functions[new_name];
        
		// This new instance of the function shouldn't be tied to the definition file of the original, so pass NULL filename, etc.
        new_info.reset(new function_info_t(*iter->second, NULL, 0, false));
        result = true;
    }
	return result;
}

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) {
        const wcstring &name = iter->first;
        
        /* Maybe skip hidden */
        if (! get_hidden) {
            if (name.size() == 0 || name.at(0) == L'_') continue;
        }
        
        names.insert(name);
    }
    
    return wcstring_list_t(names.begin(), names.end());
}

const wchar_t *function_get_definition_file( const wcstring &name )
{
    shared_ptr<function_info_t> func = function_get(name);
    return func ? func->definition_file : NULL;
}


int function_get_definition_offset( const wcstring &name )
{
    shared_ptr<function_info_t> func = function_get(name);
    return func ? func->definition_offset : -1;
}