XexprInvocation

typedef struct {
    char *ns;
    char *function;
    GSList *bindings;
    GSList *constants;
} XexprInvocation;

A structure describing the invocation of a function.

XexprFunction

typedef struct {
    GSList *args;
    GSList *constants;
} XexprFunction;

A structure describing the definition of a function.

XexprConstant

typedef struct xexpr_constant XexprConstant;

A structure describing an XEXPR expression

XexprBinding

typedef struct {
    char *id;
    XexprConstant *value;
} XexprBinding;

A structure describing the binding of a value to a name.

enum XexprType

typedef enum {
    XEXPR_TYPE_INVOCATION=1,
    XEXPR_TYPE_FUNCTION,
    XEXPR_TYPE_STRING,
    XEXPR_TYPE_INTEGER,
    XEXPR_TYPE_NUMBER
} XexprType;

Enum values for the type, to specify the type of expression.

XexprEnvironment

typedef struct {
    char *function;
    struct xexpr_environment *outer;
    GSList *bindings;
} XexprEnvironment;

A structure describing an XEXPR environment

Xexpr

typedef struct {
    GSList *constants;
    XexprEnvironment *environment;
} Xexpr;

A structure describing an XEXPR expression

XexprExtension

typedef struct {
    char *ns;
    XexprConstant *(*function_evaluate)(Xexpr *xexpr,const char *ns,
      const char *id,GSList *bindings,GSList *args,GError **err);
} XexprExtension;

A structure describing an XEXPR extension

xexpr_new_string ()

XexprConstant *     xexpr_new_string                    (const char *s,
                                                         gssize len);

Create a new XexprConstant that consists of the given string.

xexpr_new_string_take_ownership ()

XexprConstant *     xexpr_new_string_take_ownership     (char *s);

Create a new XexprConstant that consists of the given string.

xexpr_new_integer ()

XexprConstant *     xexpr_new_integer                   (long int integer);

Create a new XexprConstant that consists of the given integer.

xexpr_new_number ()

XexprConstant *     xexpr_new_number                    (double number);

Create a new XexprConstant that consists of the given floating-point number.

xexpr_new_invocation ()

XexprConstant *     xexpr_new_invocation                (const char *ns,
                                                         const char *function,
                                                         GSList *bindings,
                                                         GSList *constants);

Create a new XexprConstant that invokes function with pre-bound arguments bindings and with constants as further arguments. Functions with named parameters will use the pre-bound arguments first if present, otherwise the other arguments will be bound to the unbound parameters as needed.

ns should be NULL, the empty string or XEXPR_NS for XEXPR functions.

xexpr_new_invocation_take_ownership ()

XexprConstant *     xexpr_new_invocation_take_ownership (char *ns,
                                                         char *function,
                                                         GSList *bindings,
                                                         GSList *constants);

Create a new XexprConstant that invokes function with pre-bound arguments bindings and with constants as further arguments. Functions with named parameters will use the pre-bound arguments first if present, otherwise the other arguments will be bound to the unbound parameters as needed.

ns should be NULL, the empty string or XEXPR_NS for XEXPR functions.

xexpr_new_function_take_ownership ()

XexprConstant *     xexpr_new_function_take_ownership   (GSList *args,
                                                         GSList *constants);

Create a new XexprConstant that defines an unnamed function. Creating a function definition is the first step in defining a function. The second step is to bind the definition to a name, eg., using xexpr_var_new().

xexpr_new_function ()

XexprConstant *     xexpr_new_function                  (GSList *args,
                                                         GSList *constants);

Create a new XexprConstant that defines an unnamed function. Creating a function definition is the first step in defining a function. The second step is to bind the definition to a name, eg., using xexpr_var_new().

xexpr_constant_dup ()

XexprConstant *     xexpr_constant_dup                  (XexprConstant *constant);

Duplicate constant.

xexpr_constant_free ()

void                xexpr_constant_free                 (XexprConstant *constant);

Frees the memory allocated for the XexprConstant.

xexpr_binding_free ()

void                xexpr_binding_free                  (XexprBinding *binding);

Frees the memory allocated for the XexprBinding.

xexpr_bindings_get ()

XexprConstant *     xexpr_bindings_get                  (GSList *bindings,
                                                         const char *id);

Look for a binding of symbol id in bindings and return the value if found.

xexpr_bindings_set ()

gboolean            xexpr_bindings_set                  (GSList *bindings,
                                                         const char *id,
                                                         XexprConstant *value);

Update an existing binding of symbol id in bindings with the new value value. If no existing binding is found, return FALSE.

xexpr_bindings_new ()

GSList *            xexpr_bindings_new                  (GSList *bindings,
                                                         const char *id,
                                                         XexprConstant *value);

Update an existing binding of symbol id or create a new one in bindings with the new value value.

xexpr_bindings_dup ()

GSList *            xexpr_bindings_dup                  (GSList *bindings);

Duplicate bindings.

xexpr_new ()

Xexpr *             xexpr_new                           (void);

Creates a new Xexpr.

xexpr_sub ()

Xexpr *             xexpr_sub                           (Xexpr *xexpr);

Creates a new Xexpr, copying options from xexpr.

xexpr_var_new ()

void                xexpr_var_new                       (Xexpr *xexpr,
                                                         const char *id,
                                                         XexprConstant *value);

Update an existing binding of symbol id in the innermost environment of xexpr or create a new one with the new value value.

xexpr_var_set ()

void                xexpr_var_set                       (Xexpr *xexpr,
                                                         const char *id,
                                                         XexprConstant *value);

Update the active binding of symbol id in xexpr if such exists or create create a new one in the outermost environment with the new value value.

xexpr_var_get ()

XexprConstant *     xexpr_var_get                       (Xexpr *xexpr,
                                                         const char *id);

Look for a definition of symbol id in xexpr and return its value. If no definition exists, return NULL.

xexpr_start_tracing ()

void                xexpr_start_tracing                 (Xexpr *xexpr,
                                                         const char *id);

Adds id to the set of symbols to trace.

When variables with the name of a traced symbol are created or changed, the evaluator will output a suitable tracing message and a stack dump.

    Created new variable x in frame #0
    #0  test1 (x = <nil/>)
    #1  eq ()
    #2  if ()
    #3  and ()
    #4  expr ()
    
    Set variable x
    #0  test1 (x = <integer>1</integer>)
    #1  eq ()
    #2  if ()
    #3  and ()
    #4  expr ()
  

xexpr_is_tracing ()

gboolean            xexpr_is_tracing                    (Xexpr *xexpr,
                                                         const char *id);

Checks if a symbol is currently being traced, returning TRUE if it is.

xexpr_free ()

void                xexpr_free                          (Xexpr *xexpr);

Frees the memory allocated for the Xexpr.

xexpr_get_environment ()

XexprEnvironment *  xexpr_get_environment               (Xexpr *xexpr);

Gets the XexprEnvironment of the given Xexpr.

xexpr_environment_foreach ()

void                xexpr_environment_foreach           (XexprEnvironment *environment,
                                                         GTraverseFunc func,
                                                         gpointer user_data);

Calls a function for each active variable in an XexprEnvironment.