ok_function_return_type()

#define             ok_function_return_type(r)

n_user_functions ()

int
n_user_functions (void);

n_free_functions ()

int
n_free_functions (void);

get_user_function_by_name ()

ufunc *
get_user_function_by_name (const char *name);

get_user_function_by_index ()

const ufunc *
get_user_function_by_index (int idx);

fncall_new ()

fncall *
fncall_new (ufunc *fun);

fncall_destroy ()

void
fncall_destroy (fncall *call);

fn_n_params ()

int
fn_n_params (const ufunc *fun);

fn_param_type ()

int
fn_param_type (const ufunc *fun,
               int i);

fn_param_name ()

const char *
fn_param_name (const ufunc *fun,
               int i);

fn_param_descrip ()

const char *
fn_param_descrip (const ufunc *fun,
                  int i);

fn_param_value_labels ()

const char **
fn_param_value_labels (const ufunc *fun,
                       int i,
                       int *n);

fn_param_has_default ()

int
fn_param_has_default (const ufunc *fun,
                      int i);

fn_param_default ()

double
fn_param_default (const ufunc *fun,
                  int i);

fn_param_minval ()

double
fn_param_minval (const ufunc *fun,
                 int i);

fn_param_maxval ()

double
fn_param_maxval (const ufunc *fun,
                 int i);

fn_param_step ()

double
fn_param_step (const ufunc *fun,
               int i);

fn_param_optional ()

int
fn_param_optional (const ufunc *fun,
                   int i);

fn_param_uses_xlist ()

int
fn_param_uses_xlist (const ufunc *fun,
                     int i);

fn_param_uses_mylist ()

int
fn_param_uses_mylist (const ufunc *fun,
                      int i);

fn_param_set_const ()

int
fn_param_set_const (ufunc *fun,
                    int i);

user_func_get_return_type ()

int
user_func_get_return_type (const ufunc *fun);

user_func_is_noprint ()

int
user_func_is_noprint (const ufunc *fun);

user_func_is_menu_only ()

int
user_func_is_menu_only (const ufunc *fun);

user_function_name_by_index ()

const char *
user_function_name_by_index (int i);

user_function_index_by_name ()

int
user_function_index_by_name (const char *name,
                             fnpkg *pkg);

Looks up the 0-based index of the named function in the current array of user-functions. If pkg is non-NULL the search for name is confined to functions that belong to pkg ; otherwise the index of the first match is returned.

user_function_set_debug ()

int
user_function_set_debug (const char *name,
                         int debug);

Enables or disables debugging for a user-defined function.

function_names_init ()

void
function_names_init (void);

next_available_function_name ()

const char *
next_available_function_name (fnpkg *pkg,
                              int *idxp);

gretl_compiling_function ()

int
gretl_compiling_function (void);

gretl_compiling_python ()

int
gretl_compiling_python (const char *line);

gretl_function_depth ()

int
gretl_function_depth (void);

gretl_function_recursing ()

int
gretl_function_recursing (void);

current_function_info ()

void
current_function_info (char const **funcname,
                       char const **pkgname);

gretl_start_compiling_function ()

int
gretl_start_compiling_function (const char *line,
                                PRN *prn);

Responds to a statement of the form "function ...". In most cases, embarks on compilation of a function, but this also handles the construction "function foo delete".

gretl_function_append_line ()

int
gretl_function_append_line (const char *line);

Continuation of definition of user-function.

gretl_is_public_user_function ()

int
gretl_is_public_user_function (const char *name);

gretl_function_exec ()

int
gretl_function_exec (fncall *call,
                     int rtype,
                     DATASET *dset,
                     void *ret,
                     char **descrip,
                     PRN *prn);

attach_loop_to_function ()

int
attach_loop_to_function (void *ptr);

detach_loop_from_function ()

int
detach_loop_from_function (void *ptr);

set_function_should_return ()

int
set_function_should_return (const char *line);

current_function_size ()

int
current_function_size (void);

gretl_func_get_arg_name ()

char *
gretl_func_get_arg_name (const char *argvar,
                         int *err);

object_is_const ()

int
object_is_const (const char *name);

Checks whether the named object currently has 'const' status, by virtue of its being made available as a const argument to a user-defined function.

object_is_function_arg ()

int
object_is_function_arg (const char *name);

Checks whether the named object has been made available as a function argument.

allow_full_data_access ()

void
allow_full_data_access (int s);

sample_range_get_extrema ()

void
sample_range_get_extrema (const DATASET *dset,
                          int *t1,
                          int *t2);

Fills out t1 and/or t2 , making allowance for the possibility that we're currently executing a function, on entry to which the sample range was restricted: within the function, we are not allowed to overstep the bounds set on entry.

function_return_type_from_string ()

int
function_return_type_from_string (const char *s);

gretl_function_print_code ()

int
gretl_function_print_code (ufunc *u,
                           int tabwidth,
                           PRN *prn);

Prints out function fun to prn , script-style.

gretl_function_retrieve_code ()

char **
gretl_function_retrieve_code (ufunc *u,
                              int *nlines);

print_function_package_sample ()

int
print_function_package_sample (const char *fname,
                               int tabwidth,
                               PRN *prn);

set_current_function_package ()

void
set_current_function_package (fnpkg *pkg);

function_package_new ()

fnpkg *
function_package_new (const char *fname,
                      char **pubnames,
                      int n_pub,
                      char **privnames,
                      int n_priv,
                      int *err);

Allocates a new package with filename-member fname , including the public and private functions named in pubnames and privnames . Note that this function does not cause the package to be written to file; for that, see write_function_package().

function_package_connect_funcs ()

int
function_package_connect_funcs (fnpkg *pkg,
                                char **pubnames,
                                int n_pub,
                                char **privnames,
                                int n_priv);

Looks up the functions named in pubnames and privnames and adds pointers to these functions to pkg , hence marking the functions as belonging to pkg .

function_package_set_properties ()

int
function_package_set_properties (fnpkg *pkg,
                                 ...);

function_package_get_properties ()

int
function_package_get_properties (fnpkg *pkg,
                                 ...);

function_package_get_string ()

const char *
function_package_get_string (fnpkg *pkg,
                             const char *id);

function_package_set_data_files ()

int
function_package_set_data_files (fnpkg *pkg,
                                 char **S,
                                 int n);

function_package_get_data_files ()

char **
function_package_get_data_files (fnpkg *pkg,
                                 int *n);

function_package_get_name ()

const char *
function_package_get_name (fnpkg *pkg);

function_package_write_file ()

int
function_package_write_file (fnpkg *pkg);

Write out pkg as an XML file, using the filename recorded in the package.

create_and_write_function_package ()

int
create_and_write_function_package (const char *fname,
                                   gretlopt opt,
                                   PRN *prn);

Create a package based on the functions currently loaded, and write it out as an XML file. Responds to the makepkg command.

function_set_package_role ()

int
function_set_package_role (const char *name,
                           fnpkg *pkg,
                           const char *attr,
                           PRN *prn);

function_ok_for_package_role ()

int
function_ok_for_package_role (const char *name,
                              int role);

package_role_get_key ()

const char *
package_role_get_key (int flag);

check_function_needs ()

int
check_function_needs (const DATASET *dset,
                      DataReq dreq,
                      int minver);

Checks whether the requirements in dreq and minver are jointly satisfied by the current dataset and gretl version.

package_version_ok ()

int
package_version_ok (int minver,
                    char *reqstr);

write_loaded_functions_file ()

int
write_loaded_functions_file (const char *fname,
                             int mpicall);

read_session_functions_file ()

int
read_session_functions_file (const char *fname);

get_function_package_by_name ()

fnpkg *
get_function_package_by_name (const char *pkgname);

get_function_package_by_filename ()

fnpkg *
get_function_package_by_filename (const char *fname,
                                  int *err);

If the package whose filename is fname is already loaded, returns the package pointer, otherwise attempts to load the package from file. Similar to load_function_package_from_file() but returns the package pointer rather than just a status code.

get_function_package_path_by_name ()

const char *
get_function_package_path_by_name (const char *pkgname);

load_function_package_by_filename ()

int
load_function_package_by_filename (const char *fname,
                                   gretlopt opt,
                                   PRN *prn);

Loads the function package located by fname into memory, if possible. Supports gretl's "include" command for gfn files.

function_package_is_loaded ()

int
function_package_is_loaded (const char *fname,
                            const char **version);

gfn_is_loaded ()

int
gfn_is_loaded (const char *gfnname);

function_package_unload_by_filename ()

void
function_package_unload_by_filename (const char *fname);

Unloads the specified function package from memory, if it is currently loaded. The functions 'owned' by the package are not destroyed; they become available for inclusion in other packages.

function_package_unload_full_by_filename ()

void
function_package_unload_full_by_filename
                               (const char *fname);

Unloads the specified function package from memory, if it is currently loaded. The functions 'owned' by the package are also unloaded from memory.

delete_function_package ()

int
delete_function_package (const char *gfnname);

Deletes gfnname , taking care of deleting its enclosing specific subdirectory and all of its contents if applicable.

uninstall_function_package ()

int
uninstall_function_package (const char *package,
                            gretlopt opt,
                            PRN *prn);

print_function_package_info ()

int
print_function_package_info (const char *fname,
                             PRN *prn);

print_function_package_code ()

int
print_function_package_code (const char *fname,
                             int tabwidth,
                             PRN *prn);

get_function_from_package ()

ufunc *
get_function_from_package (const char *funname,
                           fnpkg *pkg);

get_function_file_header ()

int
get_function_file_header (const char *fname,
                          char **pdesc,
                          char **pver,
                          char **pdate,
                          char **pauthor,
                          int *pdfdoc);

function_package_get_version ()

double
function_package_get_version (const char *fname);

user_function_help ()

int
user_function_help (const char *fnname,
                    gretlopt opt,
                    PRN *prn);

Looks for a function named fnname and prints as much help information as possible.

function_package_has_PDF_doc ()

int
function_package_has_PDF_doc (fnpkg *pkg,
                              char **pdfname);

Checks whether pkg is documented in the form of a PDF file.

function_package_has_gui_help ()

int
function_package_has_gui_help (fnpkg *pkg);

Checks whether pkg has GUI-specific help text.

function_package_set_editor ()

void
function_package_set_editor (fnpkg *pkg,
                             void *editor);

function_package_get_editor ()

void *
function_package_get_editor (fnpkg *pkg);

package_has_menu_attachment ()

int
package_has_menu_attachment (const char *fname,
                             char **pkgname,
                             char **attach,
                             char **label);

package_needs_zipping ()

int
package_needs_zipping (const char *fname,
                       int *pdfdoc,
                       char ***datafiles,
                       int *n_files);

gretl_functions_cleanup ()

void
gretl_functions_cleanup (void);

For internal use: frees all resources associated with user-defined functions and function packages.

push_function_arg ()

int
push_function_arg (fncall *fc,
                   const char *name,
                   GretlType type,
                   void *value);

Writes a new argument of the specified type and value into the argument array of fun .

adjust_indent ()

void
adjust_indent (const char *line,
               int *this_indent,
               int *next_indent);

enum DataReq

enum UfunRole

enum UfunAttrs

NEEDS_TS

#define NEEDS_TS    "needs-time-series-data"

NEEDS_QM

#define NEEDS_QM    "needs-qm-data"

NEEDS_PANEL

#define NEEDS_PANEL "needs-panel-data"

NO_DATA_OK

#define NO_DATA_OK  "no-data-ok"

FN_NAMELEN

#define FN_NAMELEN 32

ufunc

typedef struct ufunc_ ufunc;

fncall

typedef struct fncall_ fncall;

fnpkg

typedef struct fnpkg_ fnpkg;