githubmirror/libxmlb

src/xb-machine.c
2 255 строк60 KB
Richard Hughes
trivial: Remove some long-dead debugging
17 янв 2022, 18:58
17 янв 2022, 18:58a85a14d
/*
 * Copyright (C) 2018 Richard Hughes <richard@hughsie.com>
 *
 * SPDX-License-Identifier: LGPL-2.1+
 */

#define G_LOG_DOMAIN "XbMachine"

#include "config.h"

#include <gio/gio.h>
#include <string.h>

#if !GLIB_CHECK_VERSION(2, 54, 0)
#include <errno.h>
#endif

#include "xb-machine-private.h"
#include "xb-opcode-private.h"
#include "xb-silo-private.h"
#include "xb-stack-private.h"
#include "xb-string-private.h"

typedef struct {
	XbMachineDebugFlags debug_flags;
	GPtrArray *methods;	   /* of XbMachineMethodItem */
	GPtrArray *operators;	   /* of XbMachineOperator */
	GPtrArray *text_handlers;  /* of XbMachineTextHandlerItem */
	GHashTable *opcode_fixup;  /* of str[XbMachineOpcodeFixupItem] */
	GHashTable *opcode_tokens; /* of utf8 */
	guint stack_size;
} XbMachinePrivate;

G_DEFINE_TYPE_WITH_PRIVATE(XbMachine, xb_machine, G_TYPE_OBJECT)
#define GET_PRIVATE(o) (xb_machine_get_instance_private(o))

typedef struct {
	gchar *str;
	gsize strsz;
	gchar *name;
} XbMachineOperator;

typedef struct {
	XbMachineOpcodeFixupFunc fixup_cb;
	gpointer user_data;
	GDestroyNotify user_data_free;
} XbMachineOpcodeFixupItem;

typedef struct {
	XbMachineTextHandlerFunc handler_cb;
	gpointer user_data;
	GDestroyNotify user_data_free;
} XbMachineTextHandlerItem;

typedef struct {
	guint32 idx;
	gchar *name;
	guint n_opcodes;
	XbMachineMethodFunc method_cb;
	gpointer user_data;
	GDestroyNotify user_data_free;
} XbMachineMethodItem;

/**
 * xb_machine_set_debug_flags:
 * @self: a #XbMachine
 * @flags: #XbMachineDebugFlags, e.g. %XB_MACHINE_DEBUG_FLAG_SHOW_STACK
 *
 * Sets the debug level of the virtual machine.
 *
 * Since: 0.1.1
 **/
void
xb_machine_set_debug_flags(XbMachine *self, XbMachineDebugFlags flags)
{
	XbMachinePrivate *priv = GET_PRIVATE(self);
	g_return_if_fail(XB_IS_MACHINE(self));
	priv->debug_flags = flags;
}

/**
 * xb_machine_add_operator:
 * @self: a #XbMachine
 * @str: operator string, e.g. `==`
 * @name: function name, e.g. `contains`
 *
 * Adds a new operator to the virtual machine. Operators can then be used
 * instead of explicit methods like `eq()`.
 *
 * You need to add a custom operator using xb_machine_add_operator() before
 * using xb_machine_parse(). Common operators like `<=` and `=` are built-in
 * and do not have to be added manually.
 *
 * Since: 0.1.1
 **/
void
xb_machine_add_operator(XbMachine *self, const gchar *str, const gchar *name)
{
	XbMachineOperator *op;
	XbMachinePrivate *priv = GET_PRIVATE(self);

	g_return_if_fail(XB_IS_MACHINE(self));
	g_return_if_fail(str != NULL);
	g_return_if_fail(name != NULL);

	op = g_slice_new0(XbMachineOperator);
	op->str = g_strdup(str);
	op->strsz = strlen(str);
	op->name = g_strdup(name);
	g_ptr_array_add(priv->operators, op);
}

/**
 * xb_machine_add_method:
 * @self: a #XbMachine
 * @name: function name, e.g. `contains`
 * @n_opcodes: minimum number of opcodes required on the stack
 * @method_cb: function to call
 * @user_data: user pointer to pass to @method_cb, or %NULL
 * @user_data_free: a function which gets called to free @user_data, or %NULL
 *
 * Adds a new function to the virtual machine. Registered functions can then be
 * used as methods.
 *
 * The @method_cb must not modify the stack it’s passed unless it’s going to
 * succeed. In particular, if a method call is not optimisable, it must not
 * modify the stack it’s passed.
 *
 * You need to add a custom function using xb_machine_add_method() before using
 * methods that may reference it, for example xb_machine_add_opcode_fixup().
 *
 * Since: 0.1.1
 **/
void
xb_machine_add_method(XbMachine *self,
		      const gchar *name,
		      guint n_opcodes,
		      XbMachineMethodFunc method_cb,
		      gpointer user_data,
		      GDestroyNotify user_data_free)
{
	XbMachineMethodItem *item;
	XbMachinePrivate *priv = GET_PRIVATE(self);

	g_return_if_fail(XB_IS_MACHINE(self));
	g_return_if_fail(name != NULL);
	g_return_if_fail(method_cb != NULL);

	item = g_slice_new0(XbMachineMethodItem);
	item->idx = priv->methods->len;
	item->name = g_strdup(name);
	item->n_opcodes = n_opcodes;
	item->method_cb = method_cb;
	item->user_data = user_data;
	item->user_data_free = user_data_free;
	g_ptr_array_add(priv->methods, item);
}

/**
 * xb_machine_add_opcode_fixup:
 * @self: a #XbMachine
 * @opcodes_sig: signature, e.g. `INTE,TEXT`
 * @fixup_cb: callback
 * @user_data: user pointer to pass to @fixup_cb
 * @user_data_free: a function which gets called to free @user_data, or %NULL
 *
 * Adds an opcode fixup. Fixups can be used to optimize the stack of opcodes or
 * to add support for a nonstandard feature, for instance supporting missing
 * attributes to functions.
 *
 * Since: 0.1.1
 **/
void
xb_machine_add_opcode_fixup(XbMachine *self,
			    const gchar *opcodes_sig,
			    XbMachineOpcodeFixupFunc fixup_cb,
			    gpointer user_data,
			    GDestroyNotify user_data_free)
{
	XbMachineOpcodeFixupItem *item = g_slice_new0(XbMachineOpcodeFixupItem);
	XbMachinePrivate *priv = GET_PRIVATE(self);
	item->fixup_cb = fixup_cb;
	item->user_data = user_data;
	item->user_data_free = user_data_free;
	g_hash_table_insert(priv->opcode_fixup, g_strdup(opcodes_sig), item);
}

/**
 * xb_machine_add_text_handler:
 * @self: a #XbMachine
 * @handler_cb: callback
 * @user_data: user pointer to pass to @handler_cb
 * @user_data_free: a function which gets called to free @user_data, or %NULL
 *
 * Adds a text handler. This allows the virtual machine to support nonstandard
 * encoding or shorthand mnemonics for standard functions.
 *
 * Since: 0.1.1
 **/
void
xb_machine_add_text_handler(XbMachine *self,
			    XbMachineTextHandlerFunc handler_cb,
			    gpointer user_data,
			    GDestroyNotify user_data_free)
{
	XbMachineTextHandlerItem *item = g_slice_new0(XbMachineTextHandlerItem);
	XbMachinePrivate *priv = GET_PRIVATE(self);
	item->handler_cb = handler_cb;
	item->user_data = user_data;
	item->user_data_free = user_data_free;
	g_ptr_array_add(priv->text_handlers, item);
}

static XbMachineMethodItem *
xb_machine_find_func(XbMachine *self, const gchar *func_name)
{
	XbMachinePrivate *priv = GET_PRIVATE(self);
	for (guint i = 0; i < priv->methods->len; i++) {
		XbMachineMethodItem *item = g_ptr_array_index(priv->methods, i);
		if (g_strcmp0(item->name, func_name) == 0)
			return item;
	}
	return NULL;
}

/**
 * xb_machine_opcode_func_init:
 * @self: a #XbMachine
 * @opcode: (out caller-allocates): a stack allocated #XbOpcode to initialise
 * @func_name: function name, e.g. `eq`
 *
 * Initialises a stack allocated #XbOpcode for a registered function.
 * Some standard functions are registered by default, for instance `eq` or `ge`.
 * Other functions have to be added using xb_machine_add_method().
 *
 * Returns: %TRUE if the function was found and the opcode initialised, %FALSE
 *    otherwise
 * Since: 0.2.0
 **/
gboolean
xb_machine_opcode_func_init(XbMachine *self, XbOpcode *opcode, const gchar *func_name)
{
	XbMachineMethodItem *item = xb_machine_find_func(self, func_name);
	if (item == NULL)
		return FALSE;
	xb_opcode_init(opcode, XB_OPCODE_KIND_FUNCTION, g_strdup(func_name), item->idx, g_free);
	return TRUE;
}

static gboolean
xb_machine_parse_add_func(XbMachine *self, XbStack *opcodes, const gchar *func_name, GError **error)
{
	XbOpcode *opcode;

	if (!xb_stack_push(opcodes, &opcode, error))
		return FALSE;

	/* match opcode, which should always exist */
	if (!xb_machine_opcode_func_init(self, opcode, func_name)) {
		g_set_error(error,
			    G_IO_ERROR,
			    G_IO_ERROR_NOT_SUPPORTED,
			    "built-in function not found: %s",
			    func_name);
		xb_stack_pop(opcodes, NULL, NULL);
		return FALSE;
	}

	return TRUE;
}

#if !GLIB_CHECK_VERSION(2, 54, 0)
static gboolean
str_has_sign(const gchar *str)
{
	return str[0] == '-' || str[0] == '+';
}

static gboolean
str_has_hex_prefix(const gchar *str)
{
	return str[0] == '0' && g_ascii_tolower(str[1]) == 'x';
}

static gboolean
g_ascii_string_to_unsigned(const gchar *str,
			   guint base,
			   guint64 min,
			   guint64 max,
			   guint64 *out_num,
			   GError **error)
{
	const gchar *end_ptr = NULL;
	gint saved_errno = 0;
	guint64 number;

	g_return_val_if_fail(str != NULL, FALSE);
	g_return_val_if_fail(base >= 2 && base <= 36, FALSE);
	g_return_val_if_fail(min <= max, FALSE);
	g_return_val_if_fail(error == NULL || *error == NULL, FALSE);

	if (str[0] == '\0') {
		g_set_error_literal(error,
				    G_IO_ERROR,
				    G_IO_ERROR_INVALID_DATA,
				    "Empty string is not a number");
		return FALSE;
	}

	errno = 0;
	number = g_ascii_strtoull(str, (gchar **)&end_ptr, base);
	saved_errno = errno;

	if (g_ascii_isspace(str[0]) || str_has_sign(str) ||
	    (base == 16 && str_has_hex_prefix(str)) ||
	    (saved_errno != 0 && saved_errno != ERANGE) || end_ptr == NULL || *end_ptr != '\0') {
		g_set_error(error,
			    G_IO_ERROR,
			    G_IO_ERROR_INVALID_DATA,
			    "“%s” is not an unsigned number",
			    str);
		return FALSE;
	}
	if (saved_errno == ERANGE || number < min || number > max) {
		g_autofree gchar *min_str = g_strdup_printf("%" G_GUINT64_FORMAT, min);
		g_autofree gchar *max_str = g_strdup_printf("%" G_GUINT64_FORMAT, max);
		g_set_error(error,
			    G_IO_ERROR,
			    G_IO_ERROR_INVALID_DATA,
			    "Number “%s” is out of bounds [%s, %s]",
			    str,
			    min_str,
			    max_str);
		return FALSE;
	}
	if (out_num != NULL)
		*out_num = number;
	return TRUE;
}
#endif

static gboolean
xb_machine_parse_add_text(XbMachine *self,
			  XbStack *opcodes,
			  const gchar *text,
			  gssize text_len,
			  GError **error)
{
	XbMachinePrivate *priv = GET_PRIVATE(self);
	g_autofree gchar *str = NULL;
	guint64 val;

	/* NULL is perfectly valid */
	if (text == NULL) {
		XbOpcode *opcode;
		if (!xb_stack_push(opcodes, &opcode, error))
			return FALSE;
		xb_opcode_text_init_static(opcode, str);
		return TRUE;
	}

	/* never add empty literals */
	if (text_len < 0)
		text_len = strlen(text);
	if (text_len == 0)
		return TRUE;

	/* do any additional handlers */
	str = g_strndup(text, text_len);
	for (guint i = 0; i < priv->text_handlers->len; i++) {
		XbMachineTextHandlerItem *item = g_ptr_array_index(priv->text_handlers, i);
		gboolean handled = FALSE;
		if (!item->handler_cb(self, opcodes, str, &handled, item->user_data, error))
			return FALSE;
		if (handled)
			return TRUE;
	}

	/* quoted text */
	if (text_len >= 2) {
		if (str[0] == '\'' && str[text_len - 1] == '\'') {
			g_autofree gchar *tmp = g_strndup(str + 1, text_len - 2);
			XbOpcode *opcode;
			if (!xb_stack_push(opcodes, &opcode, error))
				return FALSE;
			xb_opcode_text_init_steal(opcode, g_steal_pointer(&tmp));
			return TRUE;
		}
	}

	/* indexed text */
	if (text_len >= 3) {
		if (str[0] == '$' && str[1] == '\'' && str[text_len - 1] == '\'') {
			gchar *tmp = g_strndup(str + 2, text_len - 3);
			XbOpcode *opcode;
			if (!xb_stack_push(opcodes, &opcode, error))
				return FALSE;
			xb_opcode_init(opcode,
				       XB_OPCODE_KIND_INDEXED_TEXT,
				       g_steal_pointer(&tmp),
				       XB_SILO_UNSET,
				       g_free);
			return TRUE;
		}
	}

	/* bind variables */
	if (g_strcmp0(str, "?") == 0) {
		XbOpcode *opcode;
		if (!xb_stack_push(opcodes, &opcode, error))
			return FALSE;
		xb_opcode_bind_init(opcode);
		return TRUE;
	}

	/* check for plain integer */
	if (g_ascii_string_to_unsigned(str, 10, 0, G_MAXUINT32, &val, NULL)) {
		XbOpcode *opcode;
		if (!xb_stack_push(opcodes, &opcode, error))
			return FALSE;
		xb_opcode_integer_init(opcode, val);
		return TRUE;
	}

	/* not supported */
	g_set_error(error,
		    G_IO_ERROR,
		    G_IO_ERROR_NOT_SUPPORTED,
		    "cannot parse text or number `%s`",
		    str);
	return FALSE;
}

static gboolean
xb_machine_parse_section(XbMachine *self,
			 XbStack *opcodes,
			 const gchar *text,
			 gssize text_len,
			 gboolean is_method,
			 GError **error)
{
	XbMachinePrivate *priv = GET_PRIVATE(self);

	/* fall back for simplicity */
	if (text_len < 0)
		text_len = strlen(text);
	if (text_len == 0)
		return TRUE;

	for (gssize i = 0; i < text_len; i++) {
		for (guint j = 0; j < priv->operators->len; j++) {
			XbMachineOperator *op = g_ptr_array_index(priv->operators, j);
			if (strncmp(text + i, op->str, op->strsz) == 0) {
				if (is_method) {
					/* after then before */
					if (!xb_machine_parse_section(self,
								      opcodes,
								      text + i + op->strsz,
								      -1,
								      is_method,
								      error))
						return FALSE;
					if (i > 0) {
						if (!xb_machine_parse_section(self,
									      opcodes,
									      text,
									      i,
									      FALSE,
									      error))
							return FALSE;
					}
					if (!xb_machine_parse_add_func(self,
								       opcodes,
								       op->name,
								       error))
						return FALSE;
				} else {
					/* before then after */
					if (i > 0) {
						if (!xb_machine_parse_section(self,
									      opcodes,
									      text,
									      i,
									      FALSE,
									      error))
							return FALSE;
					}
					if (!xb_machine_parse_section(self,
								      opcodes,
								      text + i + op->strsz,
								      -1,
								      is_method,
								      error))
						return FALSE;
					if (!xb_machine_parse_add_func(self,
								       opcodes,
								       op->name,
								       error))
						return FALSE;
				}
				return TRUE;
			}
		}
	}

	/* nothing matched */
	if (is_method)
		return xb_machine_parse_add_func(self, opcodes, text, error);
	return xb_machine_parse_add_text(self, opcodes, text, text_len, error);
}

static gboolean
xb_machine_parse_sections(XbMachine *self,
			  XbStack *opcodes,
			  const gchar *text,
			  gsize text_len,
			  gboolean is_method,
			  GError **error)
{
	g_autofree gchar *tmp = NULL;
	if (text_len == 0)
		return TRUE;

	/* leading comma */
	if (text[0] == ',') {
		tmp = g_strndup(text + 1, text_len - 1);
	} else {
		tmp = g_strndup(text, text_len);
	}
	for (gint i = text_len - 1; i >= 0; i--) {
		if (tmp[i] == ',') {
			tmp[i] = '\0';
			if (is_method) {
				if (!xb_machine_parse_add_func(self, opcodes, tmp + i + 1, error))
					return FALSE;
				is_method = FALSE;
			} else {
				if (!xb_machine_parse_section(self,
							      opcodes,
							      tmp + i + 1,
							      -1,
							      TRUE,
							      error))
					return FALSE;
			}
		}
	}
	if (tmp[0] != '\0') {
		if (!xb_machine_parse_section(self, opcodes, tmp, -1, is_method, error))
			return FALSE;
	}
	return TRUE;
}

static gchar *
xb_machine_get_opcodes_sig(XbMachine *self, XbStack *opcodes)
{
	GString *str = g_string_new(NULL);
	for (guint i = 0; i < xb_stack_get_size(opcodes); i++) {
		XbOpcode *op = xb_stack_peek(opcodes, i);
		g_autofree gchar *sig = xb_opcode_get_sig(op);
		g_string_append_printf(str, "%s,", sig);
	}
	if (str->len > 0)
		g_string_truncate(str, str->len - 1);
	return g_string_free(str, FALSE);
}

/* @results *must* have enough space
 * @op is transfer full into this function */
static gboolean
xb_machine_opcodes_optimize_fn(XbMachine *self,
			       XbStack *opcodes,
			       XbOpcode op,
			       XbStack *results,
			       GError **error)
{
	XbMachineMethodItem *item;
	XbMachinePrivate *priv = GET_PRIVATE(self);
	g_autofree gchar *stack_str = NULL;
	g_autoptr(GError) error_local = NULL;
	g_auto(XbOpcode) op_result = XB_OPCODE_INIT();
	g_auto(XbOpcode) op_owned = op;

	/* a function! lets check the arg length */
	if (xb_opcode_get_kind(&op) != XB_OPCODE_KIND_FUNCTION) {
		XbOpcode *op_out;
		if (!xb_stack_push(results, &op_out, error))
			return FALSE;
		*op_out = xb_opcode_steal(&op_owned);
		return TRUE;
	}

	/* get function, check if we have enough arguments */
	item = g_ptr_array_index(priv->methods, xb_opcode_get_val(&op));
	if (item->n_opcodes > xb_stack_get_size(opcodes)) {
		g_set_error_literal(error,
				    G_IO_ERROR,
				    G_IO_ERROR_INVALID_DATA,
				    "predicate invalid -- not enough args");
		return FALSE;
	}

	/* run the method. it's only supposed to pop its arguments off the stack
	 * if it can complete successfully */
	stack_str = xb_stack_to_string(opcodes);
	if (!item->method_cb(self, opcodes, NULL, item->user_data, NULL, &error_local)) {
		XbOpcode *op_out;

		if (priv->debug_flags & XB_MACHINE_DEBUG_FLAG_SHOW_OPTIMIZER) {
			g_debug("ignoring optimized call to %s(%s): %s",
				item->name,
				stack_str,
				error_local->message);
		}
		if (!xb_stack_push(results, &op_out, error))
			return FALSE;
		*op_out = xb_opcode_steal(&op_owned);
		return TRUE;
	}

	/* the method ran, add the result. the arguments have already been popped */
	if (!xb_machine_stack_pop(self, opcodes, &op_result, error))
		return FALSE;
	if (xb_opcode_get_kind(&op_result) != XB_OPCODE_KIND_BOOLEAN ||
	    xb_opcode_get_val(&op_result)) {
		XbOpcode *op_out;

		if (priv->debug_flags & XB_MACHINE_DEBUG_FLAG_SHOW_OPTIMIZER) {
			g_autofree gchar *tmp = xb_opcode_to_string(&op_result);
			g_debug("method ran, adding result %s", tmp);
		}
		if (!xb_stack_push(results, &op_out, error))
			return FALSE;
		*op_out = xb_opcode_steal(&op_result);

		return TRUE;
	}

	/* the predicate will always evalulate to FALSE */
	g_set_error(error,
		    G_IO_ERROR,
		    G_IO_ERROR_INVALID_DATA,
		    "the predicate will always evalulate to FALSE: %s",
		    stack_str);
	return FALSE;
}

static gboolean
xb_machine_opcodes_optimize(XbMachine *self, XbStack *opcodes, GError **error)
{
	XbMachinePrivate *priv = GET_PRIVATE(self);
	g_autoptr(XbStack) results = xb_stack_new_inline(xb_stack_get_size(opcodes));
	g_auto(XbOpcode) op = XB_OPCODE_INIT();

	/* debug */
	if (priv->debug_flags & XB_MACHINE_DEBUG_FLAG_SHOW_OPTIMIZER) {
		g_autofree gchar *str = xb_stack_to_string(opcodes);
		g_debug("before optimizing: %s", str);
	}

	/* process the stack in reverse order */
	while (xb_machine_stack_pop(self, opcodes, &op, NULL)) {
		/* this takes ownership of @op */
		if (!xb_machine_opcodes_optimize_fn(self,
						    opcodes,
						    xb_opcode_steal(&op),
						    results,
						    error))
			return FALSE;
	}

	/* copy back the result into the opcodes stack (and reverse it) */
	while (xb_stack_pop(results, &op, NULL)) {
		XbOpcode *op_out;
		if (!xb_stack_push(opcodes, &op_out, error))
			return FALSE;
		*op_out = xb_opcode_steal(&op);
	}

	/* debug */
	if (priv->debug_flags & XB_MACHINE_DEBUG_FLAG_SHOW_OPTIMIZER) {
		g_autofree gchar *str = xb_stack_to_string(opcodes);
		g_debug("after optimizing: %s", str);
	}
	return TRUE;
}

static gsize
xb_machine_parse_text(XbMachine *self,
		      XbStack *opcodes,
		      const gchar *text,
		      gsize text_len,
		      guint level,
		      GError **error)
{
	XbMachinePrivate *priv = GET_PRIVATE(self);
	guint tail = 0;

	/* sanity check */
	if (level > 20) {
		g_autofree gchar *tmp = g_strndup(text, text_len);
		g_set_error(error,
			    G_IO_ERROR,
			    G_IO_ERROR_INVALID_DATA,
			    "nesting deeper than 20 levels supported: %s",
			    tmp);
		return G_MAXSIZE;
	}
	for (guint i = 0; i < text_len; i++) {
		if (priv->debug_flags & XB_MACHINE_DEBUG_FLAG_SHOW_PARSING)
			g_debug("LVL %u\t%u:\t\t%c", level, i, text[i]);
		if (text[i] == '(') {
			gsize j = 0;
			j = xb_machine_parse_text(self,
						  opcodes,
						  text + i + 1,
						  text_len - i,
						  level + 1,
						  error);
			if (j == G_MAXSIZE)
				return G_MAXSIZE;
			if (!xb_machine_parse_sections(self,
						       opcodes,
						       text + tail,
						       i - tail,
						       TRUE,
						       error))
				return G_MAXSIZE;
			i += j;
			tail = i + 1;
			continue;
		}
		if (text[i] == ')') {
			if (!xb_machine_parse_sections(self,
						       opcodes,
						       text + tail,
						       i - tail,
						       FALSE,
						       error))
				return G_MAXSIZE;
			return i + 1;
		}
	}
	if (tail != text_len && level > 0) {
		g_autofree gchar *tmp = g_strndup(text, text_len);
		g_set_error(error,
			    G_IO_ERROR,
			    G_IO_ERROR_INVALID_DATA,
			    "brackets did not match: %s",
			    tmp);
		return G_MAXSIZE;
	}
	if (!xb_machine_parse_sections(self, opcodes, text + tail, text_len - tail, FALSE, error))
		return G_MAXSIZE;
	return 0;
}

/**
 * xb_machine_parse_full:
 * @self: a #XbMachine
 * @text: predicate to parse, e.g. `contains(text(),'xyx')`
 * @text_len: length of @text, or -1 if @text is `NUL` terminated
 * @flags: #XbMachineParseFlags, e.g. %XB_MACHINE_PARSE_FLAG_OPTIMIZE
 * @error: a #GError, or %NULL
 *
 * Parses an XPath predicate. Not all of XPath 1.0 or XPath 1.0 is supported,
 * and new functions and mnemonics can be added using xb_machine_add_method()
 * and xb_machine_add_text_handler().
 *
 * Returns: (transfer full): opcodes, or %NULL on error
 *
 * Since: 0.1.4
 **/
XbStack *
xb_machine_parse_full(XbMachine *self,
		      const gchar *text,
		      gssize text_len,
		      XbMachineParseFlags flags,
		      GError **error)
{
	XbMachineOpcodeFixupItem *item;
	XbMachinePrivate *priv = GET_PRIVATE(self);
	guint level = 0;
	g_autoptr(XbStack) opcodes = NULL;
	g_autofree gchar *opcodes_sig = NULL;

	g_return_val_if_fail(XB_IS_MACHINE(self), NULL);
	g_return_val_if_fail(text != NULL, NULL);
	g_return_val_if_fail(error == NULL || *error == NULL, NULL);

	/* assume NUL terminated */
	if (text_len < 0)
		text_len = strlen(text);
	if (text_len == 0) {
		g_set_error_literal(error,
				    G_IO_ERROR,
				    G_IO_ERROR_INVALID_DATA,
				    "string was zero size");
		return NULL;
	}

	/* parse into opcodes */
	opcodes = xb_stack_new(priv->stack_size);
	if (xb_machine_parse_text(self, opcodes, text, text_len, level, error) == G_MAXSIZE)
		return NULL;

	/* do any fixups */
	opcodes_sig = xb_machine_get_opcodes_sig(self, opcodes);
	if (priv->debug_flags & XB_MACHINE_DEBUG_FLAG_SHOW_OPTIMIZER)
		g_debug("opcodes_sig=%s", opcodes_sig);
	item = g_hash_table_lookup(priv->opcode_fixup, opcodes_sig);
	if (item != NULL) {
		if (!item->fixup_cb(self, opcodes, item->user_data, error))
			return NULL;
	}

	/* optimize */
	if (flags & XB_MACHINE_PARSE_FLAG_OPTIMIZE) {
		for (guint i = 0; i < 10; i++) {
			guint oldsz = xb_stack_get_size(opcodes);

			/* Is the stack optimal already? */
			if (oldsz == 1)
				break;

			if (!xb_machine_opcodes_optimize(self, opcodes, error))
				return NULL;
			if (oldsz == xb_stack_get_size(opcodes))
				break;
		}
	}

	/* success */
	return g_steal_pointer(&opcodes);
}

/**
 * xb_machine_parse:
 * @self: a #XbMachine
 * @text: predicate to parse, e.g. `contains(text(),'xyx')`
 * @text_len: length of @text, or -1 if @text is `NUL` terminated
 * @error: a #GError, or %NULL
 *
 * Parses an XPath predicate. Not all of XPath 1.0 or XPath 1.0 is supported,
 * and new functions and mnemonics can be added using xb_machine_add_method()
 * and xb_machine_add_text_handler().
 *
 * Returns: (transfer full): opcodes, or %NULL on error
 *
 * Since: 0.1.1
 **/
XbStack *
xb_machine_parse(XbMachine *self, const gchar *text, gssize text_len, GError **error)
{
	return xb_machine_parse_full(self, text, text_len, XB_MACHINE_PARSE_FLAG_OPTIMIZE, error);
}

static void
xb_machine_debug_show_stack(XbMachine *self, XbStack *stack)
{
	g_autofree gchar *str = NULL;
	if (xb_stack_get_size(stack) == 0) {
		g_debug("stack is empty");
		return;
	}
	str = xb_stack_to_string(stack);
	g_debug("stack: %s", str);
}

static gboolean
xb_machine_run_func(XbMachine *self,
		    XbStack *stack,
		    XbOpcode *opcode,
		    gpointer exec_data,
		    GError **error)
{
	XbMachinePrivate *priv = GET_PRIVATE(self);
	XbMachineMethodItem *item = g_ptr_array_index(priv->methods, xb_opcode_get_val(opcode));

	/* optional debugging */
	if (priv->debug_flags & XB_MACHINE_DEBUG_FLAG_SHOW_STACK) {
		g_autofree gchar *str = xb_opcode_to_string(opcode);
		g_debug("running: %s", str);
		xb_machine_debug_show_stack(self, stack);
	}

	/* check we have enough stack elements */
	if (item->n_opcodes > xb_stack_get_size(stack)) {
		g_set_error(error,
			    G_IO_ERROR,
			    G_IO_ERROR_NOT_SUPPORTED,
			    "function required %u arguments, stack only has %u",
			    item->n_opcodes,
			    xb_stack_get_size(stack));
		return FALSE;
	}
	if (!item->method_cb(self, stack, NULL, item->user_data, exec_data, error)) {
		g_prefix_error(error, "failed to call %s(): ", item->name);
		return FALSE;
	}
	return TRUE;
}

/**
 * xb_machine_run:
 * @self: a #XbMachine
 * @opcodes: a #XbStack of opcodes
 * @result: (out): return status after running @opcodes
 * @exec_data: per-run user data that is passed to all the #XbMachineMethodFunc functions
 * @error: a #GError, or %NULL
 *
 * Runs a set of opcodes on the virtual machine.
 *
 * It is safe to call this function from a different thread to the one that
 * created the #XbMachine.
 *
 * Returns: a new #XbOpcode, or %NULL
 *
 * Since: 0.1.1
 * Deprecated: 0.3.0: Use xb_machine_run_with_bindings() instead.
 **/
gboolean
xb_machine_run(XbMachine *self,
	       XbStack *opcodes,
	       gboolean *result,
	       gpointer exec_data,
	       GError **error)
{
	return xb_machine_run_with_bindings(self, opcodes, NULL, result, exec_data, error);
}

/**
 * xb_machine_run_with_bindings:
 * @self: a #XbMachine
 * @opcodes: a #XbStack of opcodes
 * @bindings: (nullable) (transfer none): values bound to opcodes of type
 *     %XB_OPCODE_KIND_BOUND_INTEGER or %XB_OPCODE_KIND_BOUND_TEXT, or %NULL if
 *     the query doesn’t need any bound values
 * @result: (out): return status after running @opcodes
 * @exec_data: per-run user data that is passed to all the #XbMachineMethodFunc functions
 * @error: a #GError, or %NULL
 *
 * Runs a set of opcodes on the virtual machine, using the bound values given in
 * @bindings to substitute for bound opcodes.
 *
 * It is safe to call this function from a different thread to the one that
 * created the #XbMachine.
 *
 * Returns: a new #XbOpcode, or %NULL
 *
 * Since: 0.3.0
 **/
gboolean
xb_machine_run_with_bindings(XbMachine *self,
			     XbStack *opcodes,
			     XbValueBindings *bindings,
			     gboolean *result,
			     gpointer exec_data,
			     GError **error)
{
	XbMachinePrivate *priv = GET_PRIVATE(self);
	g_auto(XbOpcode) opcode_success = XB_OPCODE_INIT();
	g_autoptr(XbStack) stack = NULL;
	guint opcodes_stack_size = xb_stack_get_size(opcodes);
	guint bound_opcode_idx = 0;

	g_return_val_if_fail(XB_IS_MACHINE(self), FALSE);
	g_return_val_if_fail(opcodes != NULL, FALSE);
	g_return_val_if_fail(result != NULL, FALSE);
	g_return_val_if_fail(error == NULL || *error == NULL, FALSE);

	/* process each opcode */
	stack = xb_stack_new_inline(priv->stack_size);
	for (guint i = 0; i < opcodes_stack_size; i++) {
		XbOpcode *opcode = xb_stack_peek(opcodes, i);
		XbOpcodeKind kind = xb_opcode_get_kind(opcode);

		/* replace post-0.3.0-style bound opcodes with their bound values */
		if (bindings != NULL &&
		    (kind == XB_OPCODE_KIND_BOUND_TEXT || kind == XB_OPCODE_KIND_BOUND_INTEGER)) {
			XbOpcode *machine_opcode;
			if (!xb_machine_stack_push(self, stack, &machine_opcode, error))
				return FALSE;
			if (!xb_value_bindings_lookup_opcode(bindings,
							     bound_opcode_idx++,
							     machine_opcode)) {
				g_autofree gchar *tmp1 = xb_stack_to_string(stack);
				g_autofree gchar *tmp2 = xb_stack_to_string(opcodes);
				g_set_error(error,
					    G_IO_ERROR,
					    G_IO_ERROR_INVALID_DATA,
					    "opcode was not bound at runtime, stack:%s, opcodes:%s",
					    tmp1,
					    tmp2);
				return FALSE;
			}
			continue;
		} else if (kind == XB_OPCODE_KIND_BOUND_UNSET) {
			g_autofree gchar *tmp1 = xb_stack_to_string(stack);
			g_autofree gchar *tmp2 = xb_stack_to_string(opcodes);
			g_set_error(error,
				    G_IO_ERROR,
				    G_IO_ERROR_INVALID_DATA,
				    "opcode was not bound at runtime, stack:%s, opcodes:%s",
				    tmp1,
				    tmp2);
			return FALSE;
		}

		/* process the stack */
		if (kind == XB_OPCODE_KIND_FUNCTION) {
			if (!xb_machine_run_func(self, stack, opcode, exec_data, error))
				return FALSE;
			continue;
		}

		/* add to stack; this uses a const copy of the input opcode,
		 * so ownership of anything allocated on the heap remains with
		 * the caller */
		if (kind == XB_OPCODE_KIND_TEXT || kind == XB_OPCODE_KIND_BOOLEAN ||
		    kind == XB_OPCODE_KIND_INTEGER || kind == XB_OPCODE_KIND_INDEXED_TEXT ||
		    (bindings == NULL &&
		     (kind == XB_OPCODE_KIND_BOUND_TEXT || kind == XB_OPCODE_KIND_BOUND_INTEGER))) {
			XbOpcode *machine_opcode;
			if (!xb_machine_stack_push(self, stack, &machine_opcode, error))
				return FALSE;
			*machine_opcode = *opcode;
			machine_opcode->destroy_func = NULL;
			continue;
		}

		/* invalid */
		g_set_error(error,
			    G_IO_ERROR,
			    G_IO_ERROR_INVALID_DATA,
			    "opcode kind %u not recognised",
			    kind);
		return FALSE;
	}

	/* the stack should have one boolean left on the stack */
	if (xb_stack_get_size(stack) != 1) {
		g_autofree gchar *tmp = xb_stack_to_string(stack);
		g_set_error(error,
			    G_IO_ERROR,
			    G_IO_ERROR_INVALID_DATA,
			    "%u opcodes remain on the stack (%s)",
			    xb_stack_get_size(stack),
			    tmp);
		return FALSE;
	}
	if (!xb_stack_pop(stack, &opcode_success, error))
		return FALSE;
	if (xb_opcode_get_kind(&opcode_success) != XB_OPCODE_KIND_BOOLEAN) {
		g_autofree gchar *tmp = xb_stack_to_string(stack);
		g_set_error(error,
			    G_IO_ERROR,
			    G_IO_ERROR_INVALID_DATA,
			    "Expected boolean, got: %s",
			    tmp);
		return FALSE;
	}
	if (result != NULL)
		*result = xb_opcode_get_val(&opcode_success);

	/* success */
	return TRUE;
}

/**
 * xb_machine_stack_pop:
 * @self: a #XbMachine
 * @stack: a #XbStack
 * @opcode_out: (out caller-allocates) (optional): return location for the popped #XbOpcode
 * @error: a #GError, or %NULL
 *
 * Pops an opcode from the stack.
 *
 * Returns: %TRUE if popping succeeded, %FALSE if the stack was empty already
 *
 * Since: 0.2.0
 **/
gboolean
xb_machine_stack_pop(XbMachine *self, XbStack *stack, XbOpcode *opcode_out, GError **error)
{
	XbMachinePrivate *priv = GET_PRIVATE(self);
	gboolean retval;

	if (priv->debug_flags & XB_MACHINE_DEBUG_FLAG_SHOW_STACK) {
		XbOpcode *opcode_peek = xb_stack_peek(stack, xb_stack_get_size(stack) - 1);
		if (opcode_peek != NULL) {
			g_autofree gchar *str = xb_opcode_to_string(opcode_peek);
			g_debug("popping: %s", str);
		} else {
			g_debug("not popping: stack empty");
		}
	}

	retval = xb_stack_pop(stack, opcode_out, error);

	if (priv->debug_flags & XB_MACHINE_DEBUG_FLAG_SHOW_STACK)
		xb_machine_debug_show_stack(self, stack);

	return retval;
}

/**
 * xb_machine_stack_pop_two: (skip):
 **/
gboolean
xb_machine_stack_pop_two(XbMachine *self,
			 XbStack *stack,
			 XbOpcode *opcode1_out,
			 XbOpcode *opcode2_out,
			 GError **error)
{
	XbMachinePrivate *priv = GET_PRIVATE(self);
	gboolean retval;

	if (priv->debug_flags & XB_MACHINE_DEBUG_FLAG_SHOW_STACK) {
		XbOpcode *opcode_peek1 = xb_stack_peek(stack, xb_stack_get_size(stack) - 1);
		XbOpcode *opcode_peek2 = xb_stack_peek(stack, xb_stack_get_size(stack) - 2);
		if (opcode_peek1 != NULL && opcode_peek2 != NULL) {
			g_autofree gchar *str1 = xb_opcode_to_string(opcode_peek1);
			g_autofree gchar *str2 = xb_opcode_to_string(opcode_peek2);
			g_debug("popping1: %s", str1);
			g_debug("popping2: %s", str2);
		} else {
			g_debug("not popping: stack empty");
		}
	}

	retval = xb_stack_pop_two(stack, opcode1_out, opcode2_out, error);

	if (priv->debug_flags & XB_MACHINE_DEBUG_FLAG_SHOW_STACK)
		xb_machine_debug_show_stack(self, stack);

	return retval;
}

/**
 * xb_machine_stack_push:
 * @self: a #XbMachine
 * @stack: a #XbStack
 * @opcode_out: (out) (nullable): return location for the new #XbOpcode
 * @error: return location for a #GError, or %NULL
 *
 * Pushes a new empty opcode onto the end of the stack. A pointer to the opcode
 * is returned in @opcode_out so that the caller can initialise it.
 *
 * If the stack reaches its maximum size, %G_IO_ERROR_NO_SPACE will be returned.
 *
 * Returns: %TRUE if a new empty opcode was returned, or %FALSE if the stack has
 *    reached its maximum size
 * Since: 0.2.0
 **/
gboolean
xb_machine_stack_push(XbMachine *self, XbStack *stack, XbOpcode **opcode_out, GError **error)
{
	XbMachinePrivate *priv = GET_PRIVATE(self);

	if (priv->debug_flags & XB_MACHINE_DEBUG_FLAG_SHOW_STACK) {
		g_debug("pushing generic opcode");
	}

	return xb_stack_push(stack, opcode_out, error);
}

/**
 * xb_machine_stack_push_text:
 * @self: a #XbMachine
 * @stack: a #XbStack
 * @str: text literal
 * @error: return location for a #GError, or %NULL
 *
 * Adds a text literal to the stack, copying @str.
 *
 * Errors are as for xb_machine_stack_push().
 *
 * Returns: %TRUE on success, %FALSE otherwise
 * Since: 0.2.0
 **/
gboolean
xb_machine_stack_push_text(XbMachine *self, XbStack *stack, const gchar *str, GError **error)
{
	XbMachinePrivate *priv = GET_PRIVATE(self);
	XbOpcode *opcode;

	if (priv->debug_flags & XB_MACHINE_DEBUG_FLAG_SHOW_STACK)
		g_debug("pushing: %s", str);

	if (!xb_stack_push(stack, &opcode, error))
		return FALSE;
	xb_opcode_text_init(opcode, str);
	if (priv->debug_flags & XB_MACHINE_DEBUG_FLAG_SHOW_STACK)
		xb_machine_debug_show_stack(self, stack);

	return TRUE;
}

/**
 * xb_machine_stack_push_text_static:
 * @self: a #XbMachine
 * @stack: a #XbStack
 * @str: text literal
 * @error: return location for a #GError, or %NULL
 *
 * Adds static text literal to the stack.
 *
 * Errors are as for xb_machine_stack_push().
 *
 * Returns: %TRUE on success, %FALSE otherwise
 * Since: 0.2.0
 **/
gboolean
xb_machine_stack_push_text_static(XbMachine *self, XbStack *stack, const gchar *str, GError **error)
{
	XbOpcode *opcode;

	XbMachinePrivate *priv = GET_PRIVATE(self);
	if (priv->debug_flags & XB_MACHINE_DEBUG_FLAG_SHOW_STACK)
		g_debug("pushing: %s", str);

	if (!xb_stack_push(stack, &opcode, error))
		return FALSE;
	xb_opcode_text_init_static(opcode, str);
	if (priv->debug_flags & XB_MACHINE_DEBUG_FLAG_SHOW_STACK)
		xb_machine_debug_show_stack(self, stack);

	return TRUE;
}

/**
 * xb_machine_stack_push_text_steal:
 * @self: a #XbMachine
 * @stack: a #XbStack
 * @str: (transfer full): text literal
 * @error: return location for a #GError, or %NULL
 *
 * Adds a stolen text literal to the stack.
 *
 * Errors are as for xb_machine_stack_push().
 *
 * Returns: %TRUE on success, %FALSE otherwise
 * Since: 0.2.0
 **/
gboolean
xb_machine_stack_push_text_steal(XbMachine *self, XbStack *stack, gchar *str, GError **error)
{
	XbMachinePrivate *priv = GET_PRIVATE(self);
	XbOpcode *opcode;
	g_autofree gchar *str_stolen = g_steal_pointer(&str);

	if (priv->debug_flags & XB_MACHINE_DEBUG_FLAG_SHOW_STACK)
		g_debug("pushing: %s", str_stolen);

	if (!xb_stack_push(stack, &opcode, error))
		return FALSE;
	xb_opcode_text_init_steal(opcode, g_steal_pointer(&str_stolen));
	if (priv->debug_flags & XB_MACHINE_DEBUG_FLAG_SHOW_STACK)
		xb_machine_debug_show_stack(self, stack);

	return TRUE;
}

/**
 * xb_machine_stack_push_integer:
 * @self: a #XbMachine
 * @stack: a #XbStack
 * @val: integer literal
 * @error: return location for a #GError, or %NULL
 *
 * Adds an integer literal to the stack.
 *
 * Errors are as for xb_machine_stack_push().
 *
 * Returns: %TRUE on success, %FALSE otherwise
 * Since: 0.2.0
 **/
gboolean
xb_machine_stack_push_integer(XbMachine *self, XbStack *stack, guint32 val, GError **error)
{
	XbMachinePrivate *priv = GET_PRIVATE(self);
	XbOpcode *opcode;

	if (priv->debug_flags & XB_MACHINE_DEBUG_FLAG_SHOW_STACK)
		g_debug("pushing: %u", val);

	if (!xb_stack_push(stack, &opcode, error))
		return FALSE;
	xb_opcode_integer_init(opcode, val);
	if (priv->debug_flags & XB_MACHINE_DEBUG_FLAG_SHOW_STACK)
		xb_machine_debug_show_stack(self, stack);

	return TRUE;
}

/**
 * xb_machine_set_stack_size:
 * @self: a #XbMachine
 * @stack_size: integer
 *
 * Sets the maximum stack size used for the machine.
 *
 * The stack size will be affective for new jobs started with xb_machine_run()
 * and xb_machine_parse().
 *
 * Since: 0.1.3
 **/
void
xb_machine_set_stack_size(XbMachine *self, guint stack_size)
{
	XbMachinePrivate *priv = GET_PRIVATE(self);
	g_return_if_fail(XB_IS_MACHINE(self));
	g_return_if_fail(stack_size != 0);
	priv->stack_size = stack_size;
}

/**
 * xb_machine_get_stack_size:
 * @self: a #XbMachine
 *
 * Gets the maximum stack size used for the machine.
 *
 * Returns: integer
 *
 * Since: 0.1.3
 **/
guint
xb_machine_get_stack_size(XbMachine *self)
{
	XbMachinePrivate *priv = GET_PRIVATE(self);
	g_return_val_if_fail(XB_IS_MACHINE(self), 0);
	return priv->stack_size;
}

static const gchar *
xb_machine_intern_token(XbMachine *self, const gchar *str)
{
	XbMachinePrivate *priv = GET_PRIVATE(self);
	const gchar *tmp;
	gchar *newstr;

	/* existing value */
	tmp = g_hash_table_lookup(priv->opcode_tokens, str);
	if (tmp != NULL)
		return tmp;

	/* add as both key and value */
	newstr = g_strdup(str);
	g_hash_table_add(priv->opcode_tokens, newstr);
	return newstr;
}

/* private */
void
xb_machine_opcode_tokenize(XbMachine *self, XbOpcode *op)
{
	const gchar *str;
	g_auto(GStrv) tokens = NULL;
	g_auto(GStrv) ascii_tokens = NULL;

	/* use the fast token path even if there are no valid tokens */
	xb_opcode_add_flag(op, XB_OPCODE_FLAG_TOKENIZED);

	str = xb_opcode_get_str(op);
	tokens = g_str_tokenize_and_fold(str, NULL, &ascii_tokens);
	for (guint i = 0; tokens[i] != NULL; i++) {
		if (!xb_string_token_valid(tokens[i]))
			continue;
		xb_opcode_append_token(op, xb_machine_intern_token(self, tokens[i]));
	}
	for (guint i = 0; ascii_tokens[i] != NULL; i++) {
		if (!xb_string_token_valid(ascii_tokens[i]))
			continue;
		xb_opcode_append_token(op, xb_machine_intern_token(self, ascii_tokens[i]));
	}
}

typedef gboolean (*OpcodeCheckFunc)(XbOpcode *op);

static gboolean
xb_opcode_cmp_val_or_str(XbOpcode *op)
{
	return xb_opcode_cmp_str(op) || xb_opcode_cmp_val(op);
}

static gboolean
xb_machine_check_one_arg(XbStack *stack, OpcodeCheckFunc f, GError **error)
{
	XbOpcode *head;

	head = xb_stack_peek_tail(stack);
	if (head == NULL || !f(head)) {
		g_set_error(error,
			    G_IO_ERROR,
			    G_IO_ERROR_NOT_SUPPORTED,
			    "%s type not supported",
			    (head != NULL) ? xb_opcode_kind_to_string(xb_opcode_get_kind(head))
					   : "(null)");
		return FALSE;
	}

	return TRUE;
}

static gboolean
xb_machine_check_two_args(XbStack *stack, OpcodeCheckFunc f1, OpcodeCheckFunc f2, GError **error)
{
	XbOpcode *head1 = NULL;
	XbOpcode *head2 = NULL;
	guint stack_size = xb_stack_get_size(stack);

	if (stack_size >= 2) {
		head1 = xb_stack_peek(stack, stack_size - 1);
		head2 = xb_stack_peek(stack, stack_size - 2);
	}
	if (head1 == NULL || head2 == NULL || !f1(head1) || !f2(head2)) {
		g_set_error(error,
			    G_IO_ERROR,
			    G_IO_ERROR_NOT_SUPPORTED,
			    "%s:%s types not supported",
			    (head1 != NULL) ? xb_opcode_kind_to_string(xb_opcode_get_kind(head1))
					    : "(null)",
			    (head2 != NULL) ? xb_opcode_kind_to_string(xb_opcode_get_kind(head2))
					    : "(null)");
		return FALSE;
	}

	return TRUE;
}

static gboolean
xb_machine_func_and_cb(XbMachine *self,
		       XbStack *stack,
		       gboolean *result,
		       gpointer user_data,
		       gpointer exec_data,
		       GError **error)
{
	g_auto(XbOpcode) op1 = XB_OPCODE_INIT();
	g_auto(XbOpcode) op2 = XB_OPCODE_INIT();

	if (!xb_machine_check_two_args(stack, xb_opcode_cmp_val, xb_opcode_cmp_val, error))
		return FALSE;
	if (!xb_machine_stack_pop_two(self, stack, &op1, &op2, error))
		return FALSE;

	/* INTE:INTE */
	return xb_stack_push_bool(stack, xb_opcode_get_val(&op1) && xb_opcode_get_val(&op2), error);
}

static gboolean
xb_machine_func_or_cb(XbMachine *self,
		      XbStack *stack,
		      gboolean *result,
		      gpointer user_data,
		      gpointer exec_data,
		      GError **error)
{
	g_auto(XbOpcode) op1 = XB_OPCODE_INIT();
	g_auto(XbOpcode) op2 = XB_OPCODE_INIT();

	if (!xb_machine_check_two_args(stack, xb_opcode_cmp_val, xb_opcode_cmp_val, error))
		return FALSE;
	if (!xb_machine_stack_pop_two(self, stack, &op1, &op2, error))
		return FALSE;

	/* INTE:INTE */
	return xb_stack_push_bool(stack, xb_opcode_get_val(&op1) || xb_opcode_get_val(&op2), error);
}

static gboolean
xb_machine_func_eq_cb(XbMachine *self,
		      XbStack *stack,
		      gboolean *result,
		      gpointer user_data,
		      gpointer exec_data,
		      GError **error)
{
	g_auto(XbOpcode) op1 = XB_OPCODE_INIT();
	g_auto(XbOpcode) op2 = XB_OPCODE_INIT();

	if (!xb_machine_check_two_args(stack,
				       xb_opcode_cmp_val_or_str,
				       xb_opcode_cmp_val_or_str,
				       error))
		return FALSE;
	if (!xb_machine_stack_pop_two(self, stack, &op1, &op2, error))
		return FALSE;

	/* INTE:INTE */
	if (xb_opcode_cmp_val(&op1) && xb_opcode_cmp_val(&op2))
		return xb_stack_push_bool(stack,
					  xb_opcode_get_val(&op1) == xb_opcode_get_val(&op2),
					  error);

	/* TEXT:TEXT */
	if (xb_opcode_cmp_str(&op1) && xb_opcode_cmp_str(&op2))
		return xb_stack_push_bool(
		    stack,
		    g_strcmp0(xb_opcode_get_str(&op1), xb_opcode_get_str(&op2)) == 0,
		    error);

	/* INTE:TEXT */
	if (xb_opcode_cmp_val(&op1) && xb_opcode_cmp_str(&op2)) {
		guint64 val = 0;
		if (xb_opcode_get_str(&op2) == NULL)
			return xb_stack_push_bool(stack, FALSE, error);
		if (!g_ascii_string_to_unsigned(xb_opcode_get_str(&op2),
						10,
						0,
						G_MAXUINT32,
						&val,
						error)) {
			return FALSE;
		}
		return xb_stack_push_bool(stack, val == xb_opcode_get_val(&op1), error);
	}

	/* TEXT:INTE */
	if (xb_opcode_cmp_str(&op1) && xb_opcode_cmp_val(&op2)) {
		guint64 val = 0;
		if (xb_opcode_get_str(&op1) == NULL)
			return xb_stack_push_bool(stack, FALSE, error);
		if (!g_ascii_string_to_unsigned(xb_opcode_get_str(&op1),
						10,
						0,
						G_MAXUINT32,
						&val,
						error)) {
			return FALSE;
		}
		return xb_stack_push_bool(stack, val == xb_opcode_get_val(&op2), error);
	}

	/* should have been checked above */
	g_set_error(error,
		    G_IO_ERROR,
		    G_IO_ERROR_NOT_SUPPORTED,
		    "cannot compare %s and %s",
		    xb_opcode_kind_to_string(xb_opcode_get_kind(&op1)),
		    xb_opcode_kind_to_string(xb_opcode_get_kind(&op2)));
	return FALSE;
}

static gboolean
xb_machine_func_ne_cb(XbMachine *self,
		      XbStack *stack,
		      gboolean *result,
		      gpointer user_data,
		      gpointer exec_data,
		      GError **error)
{
	g_auto(XbOpcode) op1 = XB_OPCODE_INIT();
	g_auto(XbOpcode) op2 = XB_OPCODE_INIT();

	if (!xb_machine_check_two_args(stack,
				       xb_opcode_cmp_val_or_str,
				       xb_opcode_cmp_val_or_str,
				       error))
		return FALSE;
	if (!xb_machine_stack_pop_two(self, stack, &op1, &op2, error))
		return FALSE;

	/* INTE:INTE */
	if (xb_opcode_cmp_val(&op1) && xb_opcode_cmp_val(&op2)) {
		return xb_stack_push_bool(stack,
					  xb_opcode_get_val(&op1) != xb_opcode_get_val(&op2),
					  error);
	}

	/* TEXT:TEXT */
	if (xb_opcode_cmp_str(&op1) && xb_opcode_cmp_str(&op2)) {
		return xb_stack_push_bool(
		    stack,
		    g_strcmp0(xb_opcode_get_str(&op1), xb_opcode_get_str(&op2)) != 0,
		    error);
	}

	/* INTE:TEXT */
	if (xb_opcode_cmp_val(&op1) && xb_opcode_cmp_str(&op2)) {
		guint64 val = 0;
		if (xb_opcode_get_str(&op2) == NULL)
			return xb_stack_push_bool(stack, FALSE, error);
		if (!g_ascii_string_to_unsigned(xb_opcode_get_str(&op2),
						10,
						0,
						G_MAXUINT32,
						&val,
						error)) {
			return FALSE;
		}
		return xb_stack_push_bool(stack, val != xb_opcode_get_val(&op1), error);
	}

	/* TEXT:INTE */
	if (xb_opcode_cmp_str(&op1) && xb_opcode_cmp_val(&op2)) {
		guint64 val = 0;
		if (xb_opcode_get_str(&op1) == NULL)
			return xb_stack_push_bool(stack, FALSE, error);
		if (!g_ascii_string_to_unsigned(xb_opcode_get_str(&op1),
						10,
						0,
						G_MAXUINT32,
						&val,
						error)) {
			return FALSE;
		}
		return xb_stack_push_bool(stack, val != xb_opcode_get_val(&op2), error);
	}

	/* should have been checked above */
	g_set_error(error,
		    G_IO_ERROR,
		    G_IO_ERROR_NOT_SUPPORTED,
		    "cannot compare %s and %s",
		    xb_opcode_kind_to_string(xb_opcode_get_kind(&op1)),
		    xb_opcode_kind_to_string(xb_opcode_get_kind(&op2)));
	return FALSE;
}

static gboolean
xb_machine_func_lt_cb(XbMachine *self,
		      XbStack *stack,
		      gboolean *result,
		      gpointer user_data,
		      gpointer exec_data,
		      GError **error)
{
	g_auto(XbOpcode) op1 = XB_OPCODE_INIT();
	g_auto(XbOpcode) op2 = XB_OPCODE_INIT();

	if (!xb_machine_check_two_args(stack,
				       xb_opcode_cmp_val_or_str,
				       xb_opcode_cmp_val_or_str,
				       error))
		return FALSE;
	if (!xb_machine_stack_pop_two(self, stack, &op1, &op2, error))
		return FALSE;

	/* INTE:INTE */
	if (xb_opcode_cmp_val(&op1) && xb_opcode_cmp_val(&op2)) {
		return xb_stack_push_bool(stack,
					  xb_opcode_get_val(&op2) < xb_opcode_get_val(&op1),
					  error);
	}

	/* TEXT:TEXT */
	if (xb_opcode_cmp_str(&op1) && xb_opcode_cmp_str(&op2)) {
		return xb_stack_push_bool(
		    stack,
		    g_strcmp0(xb_opcode_get_str(&op2), xb_opcode_get_str(&op1)) < 0,
		    error);
	}

	/* INTE:TEXT */
	if (xb_opcode_cmp_val(&op1) && xb_opcode_cmp_str(&op2)) {
		guint64 val = 0;
		if (xb_opcode_get_str(&op2) == NULL)
			return xb_stack_push_bool(stack, FALSE, error);
		if (!g_ascii_string_to_unsigned(xb_opcode_get_str(&op2),
						10,
						0,
						G_MAXUINT32,
						&val,
						error)) {
			return FALSE;
		}
		return xb_stack_push_bool(stack, val < xb_opcode_get_val(&op1), error);
	}

	/* TEXT:INTE */
	if (xb_opcode_cmp_str(&op1) && xb_opcode_cmp_val(&op2)) {
		guint64 val = 0;
		if (xb_opcode_get_str(&op1) == NULL)
			return xb_stack_push_bool(stack, FALSE, error);
		if (!g_ascii_string_to_unsigned(xb_opcode_get_str(&op1),
						10,
						0,
						G_MAXUINT32,
						&val,
						error)) {
			return FALSE;
		}
		return xb_stack_push_bool(stack, val < xb_opcode_get_val(&op2), error);
	}

	/* should have been checked above */
	g_set_error(error,
		    G_IO_ERROR,
		    G_IO_ERROR_NOT_SUPPORTED,
		    "cannot compare %s and %s",
		    xb_opcode_kind_to_string(xb_opcode_get_kind(&op1)),
		    xb_opcode_kind_to_string(xb_opcode_get_kind(&op2)));
	return FALSE;
}

static gboolean
xb_machine_func_gt_cb(XbMachine *self,
		      XbStack *stack,
		      gboolean *result,
		      gpointer user_data,
		      gpointer exec_data,
		      GError **error)
{
	g_auto(XbOpcode) op1 = XB_OPCODE_INIT();
	g_auto(XbOpcode) op2 = XB_OPCODE_INIT();

	if (!xb_machine_check_two_args(stack,
				       xb_opcode_cmp_val_or_str,
				       xb_opcode_cmp_val_or_str,
				       error))
		return FALSE;
	if (!xb_machine_stack_pop_two(self, stack, &op1, &op2, error))
		return FALSE;

	/* INTE:INTE */
	if (xb_opcode_cmp_val(&op1) && xb_opcode_cmp_val(&op2)) {
		return xb_stack_push_bool(stack,
					  xb_opcode_get_val(&op2) > xb_opcode_get_val(&op1),
					  error);
	}

	/* TEXT:TEXT */
	if (xb_opcode_cmp_str(&op1) && xb_opcode_cmp_str(&op2)) {
		return xb_stack_push_bool(
		    stack,
		    g_strcmp0(xb_opcode_get_str(&op2), xb_opcode_get_str(&op1)) > 0,
		    error);
	}

	/* INTE:TEXT */
	if (xb_opcode_cmp_val(&op1) && xb_opcode_cmp_str(&op2)) {
		guint64 val = 0;
		if (xb_opcode_get_str(&op2) == NULL)
			return xb_stack_push_bool(stack, FALSE, error);
		if (!g_ascii_string_to_unsigned(xb_opcode_get_str(&op2),
						10,
						0,
						G_MAXUINT32,
						&val,
						error)) {
			return FALSE;
		}
		return xb_stack_push_bool(stack, val > xb_opcode_get_val(&op1), error);
	}

	/* TEXT:INTE */
	if (xb_opcode_cmp_str(&op1) && xb_opcode_cmp_val(&op2)) {
		guint64 val = 0;
		if (xb_opcode_get_str(&op1) == NULL)
			return xb_stack_push_bool(stack, FALSE, error);
		if (!g_ascii_string_to_unsigned(xb_opcode_get_str(&op1),
						10,
						0,
						G_MAXUINT32,
						&val,
						error)) {
			return FALSE;
		}
		return xb_stack_push_bool(stack, val > xb_opcode_get_val(&op2), error);
	}

	/* should have been checked above */
	g_set_error(error,
		    G_IO_ERROR,
		    G_IO_ERROR_NOT_SUPPORTED,
		    "cannot compare %s and %s",
		    xb_opcode_kind_to_string(xb_opcode_get_kind(&op1)),
		    xb_opcode_kind_to_string(xb_opcode_get_kind(&op2)));
	return FALSE;
}

static gboolean
xb_machine_func_le_cb(XbMachine *self,
		      XbStack *stack,
		      gboolean *result,
		      gpointer user_data,
		      gpointer exec_data,
		      GError **error)
{
	g_auto(XbOpcode) op1 = XB_OPCODE_INIT();
	g_auto(XbOpcode) op2 = XB_OPCODE_INIT();

	if (!xb_machine_check_two_args(stack,
				       xb_opcode_cmp_val_or_str,
				       xb_opcode_cmp_val_or_str,
				       error))
		return FALSE;
	if (!xb_machine_stack_pop_two(self, stack, &op1, &op2, error))
		return FALSE;

	/* INTE:INTE */
	if (xb_opcode_cmp_val(&op1) && xb_opcode_cmp_val(&op2)) {
		return xb_stack_push_bool(stack,
					  xb_opcode_get_val(&op2) <= xb_opcode_get_val(&op1),
					  error);
	}

	/* TEXT:TEXT */
	if (xb_opcode_cmp_str(&op1) && xb_opcode_cmp_str(&op2)) {
		return xb_stack_push_bool(
		    stack,
		    g_strcmp0(xb_opcode_get_str(&op2), xb_opcode_get_str(&op1)) <= 0,
		    error);
		return TRUE;
	}

	/* INTE:TEXT */
	if (xb_opcode_cmp_val(&op1) && xb_opcode_cmp_str(&op2)) {
		guint64 val = 0;
		if (xb_opcode_get_str(&op2) == NULL)
			return xb_stack_push_bool(stack, FALSE, error);
		if (!g_ascii_string_to_unsigned(xb_opcode_get_str(&op2),
						10,
						0,
						G_MAXUINT32,
						&val,
						error)) {
			return FALSE;
		}
		return xb_stack_push_bool(stack, val <= xb_opcode_get_val(&op1), error);
	}

	/* TEXT:INTE */
	if (xb_opcode_cmp_str(&op1) && xb_opcode_cmp_val(&op2)) {
		guint64 val = 0;
		if (xb_opcode_get_str(&op1) == NULL)
			return xb_stack_push_bool(stack, FALSE, error);
		if (!g_ascii_string_to_unsigned(xb_opcode_get_str(&op1),
						10,
						0,
						G_MAXUINT32,
						&val,
						error)) {
			return FALSE;
		}
		return xb_stack_push_bool(stack, val <= xb_opcode_get_val(&op2), error);
	}

	/* should have been checked above */
	g_set_error(error,
		    G_IO_ERROR,
		    G_IO_ERROR_NOT_SUPPORTED,
		    "cannot compare %s and %s",
		    xb_opcode_kind_to_string(xb_opcode_get_kind(&op1)),
		    xb_opcode_kind_to_string(xb_opcode_get_kind(&op2)));
	return FALSE;
}

static gboolean
xb_machine_func_lower_cb(XbMachine *self,
			 XbStack *stack,
			 gboolean *result,
			 gpointer user_data,
			 gpointer exec_data,
			 GError **error)
{
	g_auto(XbOpcode) op = XB_OPCODE_INIT();

	if (!xb_machine_check_one_arg(stack, xb_opcode_cmp_str, error))
		return FALSE;
	if (!xb_machine_stack_pop(self, stack, &op, error))
		return FALSE;

	/* TEXT */
	return xb_machine_stack_push_text_steal(self,
						stack,
						g_utf8_strdown(xb_opcode_get_str(&op), -1),
						error);
}

static gboolean
xb_machine_func_upper_cb(XbMachine *self,
			 XbStack *stack,
			 gboolean *result,
			 gpointer user_data,
			 gpointer exec_data,
			 GError **error)
{
	g_auto(XbOpcode) op = XB_OPCODE_INIT();

	if (!xb_machine_check_one_arg(stack, xb_opcode_cmp_str, error))
		return FALSE;
	if (!xb_machine_stack_pop(self, stack, &op, error))
		return FALSE;

	/* TEXT */
	return xb_machine_stack_push_text_steal(self,
						stack,
						g_utf8_strup(xb_opcode_get_str(&op), -1),
						error);
}

static gboolean
xb_machine_func_not_cb(XbMachine *self,
		       XbStack *stack,
		       gboolean *result,
		       gpointer user_data,
		       gpointer exec_data,
		       GError **error)
{
	g_auto(XbOpcode) op = XB_OPCODE_INIT();

	if (!xb_machine_check_one_arg(stack, xb_opcode_cmp_val_or_str, error))
		return FALSE;
	if (!xb_machine_stack_pop(self, stack, &op, error))
		return FALSE;

	/* TEXT */
	if (xb_opcode_cmp_str(&op))
		return xb_stack_push_bool(stack, xb_opcode_get_str(&op) == NULL, error);

	/* INTE */
	if (xb_opcode_cmp_val(&op))
		return xb_stack_push_bool(stack, xb_opcode_get_val(&op) == 0, error);

	/* should have been checked above */
	g_set_error(error,
		    G_IO_ERROR,
		    G_IO_ERROR_NOT_SUPPORTED,
		    "cannot invert %s",
		    xb_opcode_kind_to_string(xb_opcode_get_kind(&op)));
	return FALSE;
}

static gboolean
xb_machine_func_ge_cb(XbMachine *self,
		      XbStack *stack,
		      gboolean *result,
		      gpointer user_data,
		      gpointer exec_data,
		      GError **error)
{
	g_auto(XbOpcode) op1 = XB_OPCODE_INIT();
	g_auto(XbOpcode) op2 = XB_OPCODE_INIT();

	if (!xb_machine_check_two_args(stack,
				       xb_opcode_cmp_val_or_str,
				       xb_opcode_cmp_val_or_str,
				       error))
		return FALSE;
	if (!xb_machine_stack_pop_two(self, stack, &op1, &op2, error))
		return FALSE;

	/* TEXT:TEXT */
	if (xb_opcode_cmp_str(&op1) && xb_opcode_cmp_str(&op2)) {
		return xb_stack_push_bool(
		    stack,
		    g_strcmp0(xb_opcode_get_str(&op2), xb_opcode_get_str(&op1)) >= 0,
		    error);
	}

	/* INTE:INTE */
	if (xb_opcode_cmp_val(&op1) && xb_opcode_cmp_val(&op2)) {
		return xb_stack_push_bool(stack,
					  xb_opcode_get_val(&op2) >= xb_opcode_get_val(&op1),
					  error);
	}

	/* INTE:TEXT */
	if (xb_opcode_cmp_val(&op1) && xb_opcode_cmp_str(&op2)) {
		guint64 val = 0;
		if (xb_opcode_get_str(&op2) == NULL)
			return xb_stack_push_bool(stack, FALSE, error);
		if (!g_ascii_string_to_unsigned(xb_opcode_get_str(&op2),
						10,
						0,
						G_MAXUINT32,
						&val,
						error)) {
			return FALSE;
		}
		return xb_stack_push_bool(stack, val >= xb_opcode_get_val(&op1), error);
	}

	/* TEXT:INTE */
	if (xb_opcode_cmp_str(&op1) && xb_opcode_cmp_val(&op2)) {
		guint64 val = 0;
		if (xb_opcode_get_str(&op1) == NULL)
			return xb_stack_push_bool(stack, FALSE, error);
		if (!g_ascii_string_to_unsigned(xb_opcode_get_str(&op1),
						10,
						0,
						G_MAXUINT32,
						&val,
						error)) {
			return FALSE;
		}
		return xb_stack_push_bool(stack, val >= xb_opcode_get_val(&op2), error);
	}

	/* should have been checked above */
	g_set_error(error,
		    G_IO_ERROR,
		    G_IO_ERROR_NOT_SUPPORTED,
		    "cannot compare %s and %s",
		    xb_opcode_kind_to_string(xb_opcode_get_kind(&op1)),
		    xb_opcode_kind_to_string(xb_opcode_get_kind(&op2)));
	return FALSE;
}

static gboolean
xb_machine_func_contains_cb(XbMachine *self,
			    XbStack *stack,
			    gboolean *result,
			    gpointer user_data,
			    gpointer exec_data,
			    GError **error)
{
	g_auto(XbOpcode) op1 = XB_OPCODE_INIT();
	g_auto(XbOpcode) op2 = XB_OPCODE_INIT();

	if (!xb_machine_check_two_args(stack, xb_opcode_cmp_str, xb_opcode_cmp_str, error))
		return FALSE;
	if (!xb_machine_stack_pop_two(self, stack, &op1, &op2, error))
		return FALSE;

	/* TEXT:TEXT */
	return xb_stack_push_bool(
	    stack,
	    xb_string_contains(xb_opcode_get_str(&op2), xb_opcode_get_str(&op1)),
	    error);
}

static gboolean
xb_machine_func_starts_with_cb(XbMachine *self,
			       XbStack *stack,
			       gboolean *result,
			       gpointer user_data,
			       gpointer exec_data,
			       GError **error)
{
	g_auto(XbOpcode) op1 = XB_OPCODE_INIT();
	g_auto(XbOpcode) op2 = XB_OPCODE_INIT();

	if (!xb_machine_check_two_args(stack, xb_opcode_cmp_str, xb_opcode_cmp_str, error))
		return FALSE;
	if (!xb_machine_stack_pop_two(self, stack, &op1, &op2, error))
		return FALSE;

	/* TEXT:TEXT */
	return xb_stack_push_bool(
	    stack,
	    g_str_has_prefix(xb_opcode_get_str(&op2), xb_opcode_get_str(&op1)),
	    error);
}

static gboolean
xb_machine_func_ends_with_cb(XbMachine *self,
			     XbStack *stack,
			     gboolean *result,
			     gpointer user_data,
			     gpointer exec_data,
			     GError **error)
{
	g_auto(XbOpcode) op1 = XB_OPCODE_INIT();
	g_auto(XbOpcode) op2 = XB_OPCODE_INIT();

	if (!xb_machine_check_two_args(stack, xb_opcode_cmp_str, xb_opcode_cmp_str, error))
		return FALSE;
	if (!xb_machine_stack_pop_two(self, stack, &op1, &op2, error))
		return FALSE;

	/* TEXT:TEXT */
	return xb_stack_push_bool(
	    stack,
	    g_str_has_suffix(xb_opcode_get_str(&op2), xb_opcode_get_str(&op1)),
	    error);
}

static gboolean
xb_machine_func_number_cb(XbMachine *self,
			  XbStack *stack,
			  gboolean *result,
			  gpointer user_data,
			  gpointer exec_data,
			  GError **error)
{
	guint64 val = 0;
	g_auto(XbOpcode) op = XB_OPCODE_INIT();

	if (!xb_machine_check_one_arg(stack, xb_opcode_cmp_str, error))
		return FALSE;
	if (!xb_machine_stack_pop(self, stack, &op, error))
		return FALSE;

	/* TEXT */
	if (xb_opcode_get_str(&op) == NULL)
		return xb_stack_push_bool(stack, FALSE, error);
	if (!g_ascii_string_to_unsigned(xb_opcode_get_str(&op), 10, 0, G_MAXUINT32, &val, error)) {
		return FALSE;
	}
	return xb_machine_stack_push_integer(self, stack, val, error);
}

static gboolean
xb_machine_func_strlen_cb(XbMachine *self,
			  XbStack *stack,
			  gboolean *result,
			  gpointer user_data,
			  gpointer exec_data,
			  GError **error)
{
	g_auto(XbOpcode) op = XB_OPCODE_INIT();

	if (!xb_machine_check_one_arg(stack, xb_opcode_cmp_str, error))
		return FALSE;
	if (!xb_machine_stack_pop(self, stack, &op, error))
		return FALSE;

	/* TEXT */
	if (xb_opcode_get_str(&op) == NULL)
		return xb_stack_push_bool(stack, FALSE, error);
	return xb_machine_stack_push_integer(self, stack, strlen(xb_opcode_get_str(&op)), error);
}

static gboolean
xb_machine_func_string_cb(XbMachine *self,
			  XbStack *stack,
			  gboolean *result,
			  gpointer user_data,
			  gpointer exec_data,
			  GError **error)
{
	gchar *tmp;
	g_auto(XbOpcode) op = XB_OPCODE_INIT();

	if (!xb_machine_check_one_arg(stack, xb_opcode_cmp_val, error))
		return FALSE;
	if (!xb_machine_stack_pop(self, stack, &op, error))
		return FALSE;

	/* INTE */
	tmp = g_strdup_printf("%" G_GUINT32_FORMAT, xb_opcode_get_val(&op));
	return xb_machine_stack_push_text_steal(self, stack, tmp, error);
}

static void
xb_machine_opcode_fixup_free(XbMachineOpcodeFixupItem *item)
{
	if (item->user_data_free != NULL)
		item->user_data_free(item->user_data);
	g_slice_free(XbMachineOpcodeFixupItem, item);
}

static void
xb_machine_func_free(XbMachineMethodItem *item)
{
	if (item->user_data_free != NULL)
		item->user_data_free(item->user_data);
	g_free(item->name);
	g_slice_free(XbMachineMethodItem, item);
}

static void
xb_machine_text_handler_free(XbMachineTextHandlerItem *item)
{
	if (item->user_data_free != NULL)
		item->user_data_free(item->user_data);
	g_slice_free(XbMachineTextHandlerItem, item);
}

static void
xb_machine_operator_free(XbMachineOperator *op)
{
	g_free(op->str);
	g_free(op->name);
	g_slice_free(XbMachineOperator, op);
}

static void
xb_machine_init(XbMachine *self)
{
	XbMachinePrivate *priv = GET_PRIVATE(self);
	priv->stack_size = 10;
	priv->methods = g_ptr_array_new_with_free_func((GDestroyNotify)xb_machine_func_free);
	priv->operators = g_ptr_array_new_with_free_func((GDestroyNotify)xb_machine_operator_free);
	priv->text_handlers =
	    g_ptr_array_new_with_free_func((GDestroyNotify)xb_machine_text_handler_free);
	priv->opcode_fixup = g_hash_table_new_full(g_str_hash,
						   g_str_equal,
						   g_free,
						   (GDestroyNotify)xb_machine_opcode_fixup_free);
	priv->opcode_tokens = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);

	/* built-in functions */
	xb_machine_add_method(self, "and", 2, xb_machine_func_and_cb, NULL, NULL);
	xb_machine_add_method(self, "or", 2, xb_machine_func_or_cb, NULL, NULL);
	xb_machine_add_method(self, "eq", 2, xb_machine_func_eq_cb, NULL, NULL);
	xb_machine_add_method(self, "ne", 2, xb_machine_func_ne_cb, NULL, NULL);
	xb_machine_add_method(self, "lt", 2, xb_machine_func_lt_cb, NULL, NULL);
	xb_machine_add_method(self, "gt", 2, xb_machine_func_gt_cb, NULL, NULL);
	xb_machine_add_method(self, "le", 2, xb_machine_func_le_cb, NULL, NULL);
	xb_machine_add_method(self, "ge", 2, xb_machine_func_ge_cb, NULL, NULL);
	xb_machine_add_method(self, "not", 1, xb_machine_func_not_cb, NULL, NULL);
	xb_machine_add_method(self, "lower-case", 1, xb_machine_func_lower_cb, NULL, NULL);
	xb_machine_add_method(self, "upper-case", 1, xb_machine_func_upper_cb, NULL, NULL);
	xb_machine_add_method(self, "contains", 2, xb_machine_func_contains_cb, NULL, NULL);
	xb_machine_add_method(self, "starts-with", 2, xb_machine_func_starts_with_cb, NULL, NULL);
	xb_machine_add_method(self, "ends-with", 2, xb_machine_func_ends_with_cb, NULL, NULL);
	xb_machine_add_method(self, "string", 1, xb_machine_func_string_cb, NULL, NULL);
	xb_machine_add_method(self, "number", 1, xb_machine_func_number_cb, NULL, NULL);
	xb_machine_add_method(self, "string-length", 1, xb_machine_func_strlen_cb, NULL, NULL);

	/* built-in operators */
	xb_machine_add_operator(self, " and ", "and");
	xb_machine_add_operator(self, " or ", "or");
	xb_machine_add_operator(self, "&&", "and");
	xb_machine_add_operator(self, "||", "or");
	xb_machine_add_operator(self, "!=", "ne");
	xb_machine_add_operator(self, "<=", "le");
	xb_machine_add_operator(self, ">=", "ge");
	xb_machine_add_operator(self, "==", "eq");
	xb_machine_add_operator(self, "=", "eq");
	xb_machine_add_operator(self, ">", "gt");
	xb_machine_add_operator(self, "<", "lt");
}

static void
xb_machine_finalize(GObject *obj)
{
	XbMachine *self = XB_MACHINE(obj);
	XbMachinePrivate *priv = GET_PRIVATE(self);
	g_ptr_array_unref(priv->methods);
	g_ptr_array_unref(priv->operators);
	g_ptr_array_unref(priv->text_handlers);
	g_hash_table_unref(priv->opcode_fixup);
	g_hash_table_unref(priv->opcode_tokens);
	G_OBJECT_CLASS(xb_machine_parent_class)->finalize(obj);
}

static void
xb_machine_class_init(XbMachineClass *klass)
{
	GObjectClass *object_class = G_OBJECT_CLASS(klass);
	object_class->finalize = xb_machine_finalize;
}

/**
 * xb_machine_new:
 *
 * Creates a new virtual machine.
 *
 * Returns: a new #XbMachine
 *
 * Since: 0.1.1
 **/
XbMachine *
xb_machine_new(void)
{
	return g_object_new(XB_TYPE_MACHINE, NULL);
}