#ifndef __XEXPER_TYPES_H__

 #define __XEXPER_TYPES_H__

 #include <glib.h>

 #include <libxml/tree.h>

 G_BEGIN_DECLS

 /**

  * XexprInvocation:

  * @ns: the namespace to which @function belongs, or %NULL

  * @function: the function to be invoked

  * @bindings: (element-type XexprBinding): the pre-bound arguments

  * @constants: (element-type XexprConstant): the other arguments

  *

  * A structure describing the invocation of a function.

  */

 typedef struct xexpr_invocation {

     char *ns;

     char *function;

     GSList *bindings;

     GSList *constants;

 } XexprInvocation;

 /**

  * XexprFunction:

  * @args: (element-type utf8): the parameter names

  * @constants: (element-type XexprConstant): the constants

  *   which will be evaluated when the function is invoked

  *

  * A structure describing the definition of a function.

  */

 typedef struct xexpr_function {

     GSList *args;

     GSList *constants;

 } XexprFunction;

 typedef struct xexpr_constant XexprConstant;

 /**

  * XexprBinding:

  * @id: the bound name

  * @value: the expresion bound to @id

  *

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

  */

 typedef struct xexpr_binding {

     char *id;

     XexprConstant *value;

 } XexprBinding;

 /**

  * XexprType:

  * @XEXPR_TYPE_INVOCATION: a function invocation

  * @XEXPR_TYPE_FUNCTION: a function definition

  * @XEXPR_TYPE_STRING: a string

  * @XEXPR_TYPE_INTEGER: an integer

  * @XEXPR_TYPE_NUMBER: a floating-point number

  *

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

  */

 typedef enum {

     XEXPR_TYPE_INVOCATION=1,

     XEXPR_TYPE_FUNCTION,

     XEXPR_TYPE_STRING,

     XEXPR_TYPE_INTEGER,

     XEXPR_TYPE_NUMBER

 } XexprType;

 /**

  * XexprConstant:

  * @type: the type of expression

  * @u: type-specific parameters

  *

  * A structure describing an XEXPR expression

  */

 struct xexpr_constant {

     XexprType type;

     union {

 	XexprInvocation *invocation;

 	XexprFunction *function;

 	char *string;

 	long long int integer;

 	double number;

     } u;

 };

 /**

  * XexprEnvironment:

  * @function: the name of the function to which the environment belongs,

  *   or %NULL if this is the outermost environment

  * @outer: the next environment in the chain from innermost to outermost,

  *   or %NULL if this is the outermost environment

  * @bindings: (element-type XexprBinding): the variables set in this environment

  *

  * A structure describing an XEXPR environment

  */

 typedef struct xexpr_environment {

     /*< private >*/

     int refcount;

     /*< public >*/

     char *function;

     struct xexpr_environment *outer;

     GSList *bindings;

 } XexprEnvironment;

 /**

  * Xexpr:

  * @constants: (element-type XexprConstant): the constants that make up this

  *   expression

  * @environment: the innermost environment

  *

  * A structure describing an XEXPR expression

  */

 typedef struct xexpr {

     /*< private >*/

     GSList *tracing;

     /*< public >*/

     GSList *constants;

     XexprEnvironment *environment;

 } Xexpr;

 /**

  * XexprExtension:

  * @ns: the namespace of the extension

  * @function_evaluate: evaluates functions defined in the extension

  *

  * A structure describing an XEXPR extension

  */

 typedef struct xexpr_extension {

     char *ns;

     XexprConstant *(*function_evaluate)(Xexpr *xexpr,const char *ns,

       const char *id,GSList *bindings,GSList *args,GError **err);

 } XexprExtension;

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

 XexprConstant *xexpr_new_string_take_ownership(char *s);

 XexprConstant *xexpr_new_integer(long long int integer);

 XexprConstant *xexpr_new_number(double number);

 XexprConstant *xexpr_new_invocation(const char *ns,const char *function,

   GSList *bindings,GSList *constants);

 XexprConstant *xexpr_new_invocation_take_ownership(char *ns,char *function,

   GSList *bindings,GSList *constants);

 XexprConstant *xexpr_new_function_take_ownership(GSList *args,

   GSList *constants);

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

 XexprConstant *xexpr_constant_dup(XexprConstant *constant);

 void xexpr_constant_free(XexprConstant *constant);

 void xexpr_binding_free(XexprBinding *binding);

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

 gboolean xexpr_bindings_set(GSList *bindings,const char *id,

   XexprConstant *value);

 GSList *xexpr_bindings_new(GSList *bindings,const char *id,

   XexprConstant *value);

 GSList *xexpr_bindings_dup(GSList *bindings);

 Xexpr *xexpr_new(void);

 Xexpr *xexpr_sub(Xexpr *xexpr);

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

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

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

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

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

 void xexpr_free(Xexpr *xexpr);

 XexprEnvironment *xexpr_get_environment(Xexpr *xexpr);

 void xexpr_set_constants(Xexpr *xexpr,GSList *constants);

 void xexpr_set_constants_take_ownership(Xexpr *xexpr,GSList *constants);

 void xexpr_environment_foreach(XexprEnvironment *environment,GTraverseFunc func,

   gpointer user_data);

 G_END_DECLS

 #endif	/* __XEXPER_TYPES_H__ */