enum FuncDataReq

typedef enum {
    FN_NEEDS_TS = 1, /* function requires time-series data */
    FN_NEEDS_QM,     /* function requires quarterly or monthly data */
    FN_NEEDS_PANEL,  /* function requires panel data */
    FN_NODATA_OK     /* function does not require a dataset */
} FuncDataReq;

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;

fnpkg

typedef struct fnpkg_ fnpkg;

fnargs

typedef struct fnargs_ fnargs;

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);

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_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_optional ()

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

user_func_get_return_type ()

int                 user_func_get_return_type           (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);

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        (int *idxp);

gretl_compiling_function ()

int                 gretl_compiling_function            (void);

gretl_function_depth ()

int                 gretl_function_depth                (void);

gretl_start_compiling_function ()

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

Responds to a command 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                 (ufunc *u,
                                                         fnargs *args,
                                                         int rtype,
                                                         double ***pZ,
                                                         DATAINFO *pdinfo,
                                                         void *ret,
                                                         char **descrip,
                                                         PRN *prn);

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 it's being made available as a const argument to a user function.

sample_range_get_extrema ()

void                sample_range_get_extrema            (const DATAINFO *pdinfo,
                                                         int *t1,
                                                         int *t2);

Fills out t1 and 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.

get_funcerr_message ()

const char *        get_funcerr_message                 (void);

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,
                                                         PRN *prn);

Prints out function fun to prn, script-style.

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_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.

check_function_needs ()

int                 check_function_needs                (const DATAINFO *pdinfo,
                                                         FuncDataReq dreq,
                                                         int minver);

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

write_session_functions_file ()

int                 write_session_functions_file        (const char *fname);

read_session_functions_file ()

int                 read_session_functions_file         (const char *fname);

get_function_package_by_filename ()

fnpkg *             get_function_package_by_filename    (const char *fname);

load_function_package_from_file ()

int                 load_function_package_from_file     (const char *fname);

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.

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,
                                                         PRN *prn);

get_packaged_function_by_name ()

ufunc *             get_packaged_function_by_name       (const char *name,
                                                         fnpkg *pkg);

get_function_file_header ()

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

update_function_from_script ()

int                 update_function_from_script         (const char *funname,
                                                         const char *path,
                                                         fnpkg *pkg);

user_function_help ()

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

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

gretl_functions_cleanup ()

void                gretl_functions_cleanup             (void);

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

fn_args_new ()

fnargs *            fn_args_new                         (void);

fn_args_free ()

void                fn_args_free                        (fnargs *args);

push_fn_arg ()

int                 push_fn_arg                         (fnargs *args,
                                                         int type,
                                                         void *p);

Appends a new argument of the specified type and value to the array args.

adjust_indent ()

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