cairo/cairo-1.14.12/util/cairo-script/cairo-script-objects.c

/*
 * Copyright © 2008 Chris Wilson <chris@chris-wilson.co.uk>
 *
 * This library is free software; you can redistribute it and/or
 * modify it either under the terms of the GNU Lesser General Public
 * License version 2.1 as published by the Free Software Foundation
 * (the "LGPL") or, at your option, under the terms of the Mozilla
 * Public License Version 1.1 (the "MPL"). If you do not alter this
 * notice, a recipient may use your version of this file under either
 * the MPL or the LGPL.
 *
 * You should have received a copy of the LGPL along with this library
 * in the file COPYING-LGPL-2.1; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
 * You should have received a copy of the MPL along with this library
 * in the file COPYING-MPL-1.1
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
 * OF ANY KIND, either express or implied. See the LGPL or the MPL for
 * the specific language governing rights and limitations.
 *
 * The Original Code is the cairo graphics library.
 *
 * The Initial Developer of the Original Code is Chris Wilson.
 *
 * Contributor(s):
 *	Chris Wilson <chris@chris-wilson.co.uk>
 */

#include "config.h"

#include "cairo-script-private.h"

#include <limits.h> /* INT_MAX */
#include <string.h>

csi_status_t
csi_array_new (csi_t *ctx,
	       csi_integer_t initial_size,
	       csi_object_t *obj)

{
    csi_array_t *array;

    if (ctx->free_array == NULL ||
	ctx->free_array->stack.size <= initial_size)
    {
	csi_status_t status;

	array = _csi_slab_alloc (ctx, sizeof (csi_array_t));
	if (_csi_unlikely (array == NULL))
	    return _csi_error (CSI_STATUS_NO_MEMORY);

	status = _csi_stack_init (ctx, &array->stack,
				  initial_size ? initial_size : 32);
	if (_csi_unlikely (status)) {
	    _csi_slab_free (ctx, array, sizeof (csi_array_t));
	    return status;
	}
    } else {
	array = ctx->free_array;
	ctx->free_array = NULL;
    }

    array->base.type = CSI_OBJECT_TYPE_ARRAY;
    array->base.ref = 1;

    obj->type = CSI_OBJECT_TYPE_ARRAY;
    obj->datum.array = array;

    return CSI_STATUS_SUCCESS;
}

csi_status_t
csi_array_put (csi_t *ctx,
	       csi_array_t *array,
	       csi_integer_t elem,
	       csi_object_t *value)
{
    if (_csi_unlikely (elem < 0))
	return _csi_error (CSI_STATUS_INVALID_SCRIPT);

    if (_csi_unlikely (elem >= array->stack.len)) {
	csi_status_t status;

	status = _csi_stack_grow (ctx, &array->stack, elem + 1);
	if (_csi_unlikely (status))
	    return status;

	memset (array->stack.objects + array->stack.len,
		0, (elem - array->stack.len + 1) * sizeof (csi_object_t));
	array->stack.len = elem + 1;
    }

    csi_object_free (ctx, &array->stack.objects[elem]);
    array->stack.objects[elem] = *csi_object_reference (value);

    return CSI_STATUS_SUCCESS;
}

csi_status_t
csi_array_get (csi_t *ctx,
	       csi_array_t *array,
	       csi_integer_t elem,
	       csi_object_t *value)
{
    if (_csi_unlikely (elem < 0))
	return _csi_error (CSI_STATUS_INVALID_SCRIPT);

    if (_csi_unlikely (elem > array->stack.len))
	return _csi_error (CSI_STATUS_INVALID_SCRIPT);

    *value = array->stack.objects[elem];
    return CSI_STATUS_SUCCESS;
}

csi_status_t
csi_array_append (csi_t *ctx,
		  csi_array_t *array,
		  csi_object_t *obj)
{
    return _csi_stack_push (ctx, &array->stack, csi_object_reference (obj));
}

inline csi_status_t
_csi_array_execute (csi_t *ctx, csi_array_t *array)
{
    csi_integer_t i;
    csi_status_t status;

    if (_csi_unlikely (array->stack.len == 0))
	return CSI_STATUS_SUCCESS;

    for (i = 0; i < array->stack.len; i++) {
	csi_object_t *obj = &array->stack.objects[i];

	if (obj->type & CSI_OBJECT_ATTR_EXECUTABLE) {
	    if (obj->type == (CSI_OBJECT_TYPE_ARRAY |
			      CSI_OBJECT_ATTR_EXECUTABLE))
	    {
		status = _csi_push_ostack_copy (ctx, &array->stack.objects[i]);
	    }
	    else
		status = csi_object_execute (ctx, &array->stack.objects[i]);
	} else
	    status = _csi_push_ostack_copy (ctx, &array->stack.objects[i]);
	if (_csi_unlikely (status))
	    return status;
    }

    return CSI_STATUS_SUCCESS;
}

void
csi_array_free (csi_t *ctx, csi_array_t *array)
{
#if CSI_DEBUG_MALLOC
    _csi_stack_fini (ctx, &array->stack);
    _csi_slab_free (ctx, array, sizeof (csi_array_t));
#else
    csi_integer_t n;

    for (n = 0; n < array->stack.len; n++)
	csi_object_free (ctx, &array->stack.objects[n]);
    array->stack.len = 0;

    if (ctx->free_array != NULL) {
	if (array->stack.size > ctx->free_array->stack.size) {
	    csi_array_t *tmp = ctx->free_array;
	    ctx->free_array = array;
	    array = tmp;
	}

	_csi_stack_fini (ctx, &array->stack);
	_csi_slab_free (ctx, array, sizeof (csi_array_t));
    } else
	ctx->free_array = array;
#endif
}

static cairo_bool_t
_dictionary_name_equal (const void *_a, const void *_b)
{
    return TRUE;
}

csi_status_t
csi_dictionary_new (csi_t *ctx,
		    csi_object_t *obj)

{
    csi_dictionary_t *dict;

    if (ctx->free_dictionary != NULL) {
	dict = ctx->free_dictionary;
	ctx->free_dictionary = NULL;
    } else {
	csi_status_t status;

	dict = _csi_slab_alloc (ctx, sizeof (csi_dictionary_t));
	if (_csi_unlikely (dict == NULL))
	    return _csi_error (CSI_STATUS_NO_MEMORY);

	status = _csi_hash_table_init (&dict->hash_table,
				       _dictionary_name_equal);
	if (_csi_unlikely (status)) {
	    _csi_slab_free (ctx, dict, sizeof (csi_dictionary_t));
	    return status;
	}
    }

    dict->base.type = CSI_OBJECT_TYPE_DICTIONARY;
    dict->base.ref = 1;

    obj->type = CSI_OBJECT_TYPE_DICTIONARY;
    obj->datum.dictionary = dict;

    return CSI_STATUS_SUCCESS;
}

struct _dictionary_entry_pluck {
    csi_t *ctx;
    csi_hash_table_t *hash_table;
};

static void
_dictionary_entry_pluck (void *entry, void *data)
{
    csi_dictionary_entry_t *dict_entry;
    struct _dictionary_entry_pluck *pluck_data;

    dict_entry = entry;
    pluck_data = data;

    _csi_hash_table_remove (pluck_data->hash_table, entry);
    csi_object_free (pluck_data->ctx, &dict_entry->value);
    _csi_slab_free (pluck_data->ctx, entry, sizeof (csi_dictionary_entry_t));
}

void
csi_dictionary_free (csi_t *ctx,
		     csi_dictionary_t *dict)
{
    struct _dictionary_entry_pluck data;

    data.ctx = ctx;
    data.hash_table = &dict->hash_table;
    _csi_hash_table_foreach (&dict->hash_table,
			     _dictionary_entry_pluck,
			     &data);

#if CSI_DEBUG_MALLOC
    _csi_hash_table_fini (&dict->hash_table);
    _csi_slab_free (ctx, dict, sizeof (csi_dictionary_t));
#else
    if (ctx->free_dictionary != NULL) {
	_csi_hash_table_fini (&dict->hash_table);
	_csi_slab_free (ctx, dict, sizeof (csi_dictionary_t));
    } else
	ctx->free_dictionary = dict;
#endif
}

csi_status_t
csi_dictionary_put (csi_t *ctx,
		    csi_dictionary_t *dict,
		    csi_name_t name,
		    csi_object_t *value)
{
    csi_dictionary_entry_t *entry;
    csi_status_t status;

    entry = _csi_hash_table_lookup (&dict->hash_table,
				    (csi_hash_entry_t *) &name);
    if (entry != NULL) {
	/* replace the existing entry */
	csi_object_free (ctx, &entry->value);
	entry->value = *csi_object_reference (value);
	return CSI_STATUS_SUCCESS;
    }

    entry = _csi_slab_alloc (ctx, sizeof (*entry));
    if (_csi_unlikely (entry == NULL))
	return _csi_error (CSI_STATUS_NO_MEMORY);

    entry->hash_entry.hash = name;
    status = _csi_hash_table_insert (&dict->hash_table, &entry->hash_entry);
    if (_csi_unlikely (status)) {
	_csi_slab_free (ctx, entry, sizeof (*entry));
	return status;
    }

    entry->value = *csi_object_reference (value);

    return CSI_STATUS_SUCCESS;
}

csi_status_t
csi_dictionary_get (csi_t *ctx,
		    csi_dictionary_t *dict,
		    csi_name_t name,
		    csi_object_t *value)
{
    csi_dictionary_entry_t *entry;

    entry = _csi_hash_table_lookup (&dict->hash_table,
				    (csi_hash_entry_t *) &name);
    if (_csi_unlikely (entry == NULL))
	return _csi_error (CSI_STATUS_INVALID_SCRIPT);

    *value = entry->value;
    return CSI_STATUS_SUCCESS;
}

csi_boolean_t
csi_dictionary_has (csi_dictionary_t *dict,
		    csi_name_t name)
{
    return _csi_hash_table_lookup (&dict->hash_table,
				   (csi_hash_entry_t *) &name) != NULL;
}

void
csi_dictionary_remove (csi_t *ctx,
		       csi_dictionary_t *dict,
		       csi_name_t name)
{
    csi_dictionary_entry_t *entry;

    entry = _csi_hash_table_lookup (&dict->hash_table,
				    (csi_hash_entry_t *) &name);
    if (entry != NULL) {
	_csi_hash_table_remove (&dict->hash_table, &entry->hash_entry);
	csi_object_free (ctx, &entry->value);
	_csi_slab_free (ctx, entry, sizeof (csi_dictionary_entry_t));
    }
}

csi_status_t
csi_matrix_new (csi_t *ctx,
		csi_object_t *obj)
{
    csi_matrix_t *matrix;

    matrix = _csi_slab_alloc (ctx, sizeof (csi_matrix_t));
    if (_csi_unlikely (matrix == NULL))
	return _csi_error (CSI_STATUS_NO_MEMORY);

    matrix->base.type = CSI_OBJECT_TYPE_MATRIX;
    matrix->base.ref = 1;
    cairo_matrix_init_identity (&matrix->matrix);

    obj->type = CSI_OBJECT_TYPE_MATRIX;
    obj->datum.matrix = matrix;

    return CSI_STATUS_SUCCESS;
}

csi_status_t
csi_matrix_new_from_array (csi_t *ctx,
			   csi_object_t *obj,
			   csi_array_t *array)
{
    csi_matrix_t *matrix;

    if (_csi_unlikely (array->stack.len != 6))
	return _csi_error (CSI_STATUS_INVALID_SCRIPT);

    matrix = _csi_slab_alloc (ctx, sizeof (csi_matrix_t));
    if (_csi_unlikely (matrix == NULL))
	return _csi_error (CSI_STATUS_NO_MEMORY);

    matrix->base.type = CSI_OBJECT_TYPE_MATRIX;
    matrix->base.ref = 1;
    cairo_matrix_init (&matrix->matrix,
		       csi_number_get_value (&array->stack.objects[0]),
		       csi_number_get_value (&array->stack.objects[1]),
		       csi_number_get_value (&array->stack.objects[2]),
		       csi_number_get_value (&array->stack.objects[3]),
		       csi_number_get_value (&array->stack.objects[4]),
		       csi_number_get_value (&array->stack.objects[5]));

    obj->type = CSI_OBJECT_TYPE_MATRIX;
    obj->datum.matrix = matrix;

    return CSI_STATUS_SUCCESS;
}

csi_status_t
csi_matrix_new_from_matrix (csi_t *ctx,
			    csi_object_t *obj,
			    const cairo_matrix_t *m)
{
    csi_matrix_t *matrix;

    matrix = _csi_slab_alloc (ctx, sizeof (csi_matrix_t));
    if (_csi_unlikely (matrix == NULL))
	return _csi_error (CSI_STATUS_NO_MEMORY);

    matrix->base.type = CSI_OBJECT_TYPE_MATRIX;
    matrix->base.ref = 1;
    matrix->matrix = *m;

    obj->type = CSI_OBJECT_TYPE_MATRIX;
    obj->datum.matrix = matrix;

    return CSI_STATUS_SUCCESS;
}

csi_status_t
csi_matrix_new_from_values (csi_t *ctx,
			    csi_object_t *obj,
			    double v[6])
{
    csi_matrix_t *matrix;

    matrix = _csi_slab_alloc (ctx, sizeof (csi_matrix_t));
    if (_csi_unlikely (matrix == NULL))
	return _csi_error (CSI_STATUS_NO_MEMORY);

    matrix->base.type = CSI_OBJECT_TYPE_MATRIX;
    matrix->base.ref = 1;
    cairo_matrix_init (&matrix->matrix, v[0], v[1], v[2], v[3], v[4], v[5]);

    obj->type = CSI_OBJECT_TYPE_MATRIX;
    obj->datum.matrix = matrix;

    return CSI_STATUS_SUCCESS;
}

void
csi_matrix_free (csi_t *ctx,
		 csi_matrix_t *obj)
{
    _csi_slab_free (ctx, obj, sizeof (csi_matrix_t));
}


csi_status_t
csi_name_new (csi_t *ctx,
	      csi_object_t *obj,
	      const char *str,
	      int len)
{
    csi_status_t status;

    status = _csi_intern_string (ctx, &str, len);
    if (_csi_unlikely (status))
	return status;

    obj->type = CSI_OBJECT_TYPE_NAME;
    obj->datum.name = (csi_name_t) str;

    return CSI_STATUS_SUCCESS;
}

csi_status_t
csi_name_new_static (csi_t *ctx,
		     csi_object_t *obj,
		     const char *str)
{
    csi_status_t status;

    status = _csi_intern_string (ctx, &str, strlen (str));
    if (_csi_unlikely (status))
	return status;

    obj->type = CSI_OBJECT_TYPE_NAME;
    obj->datum.name = (csi_name_t) str;

    return CSI_STATUS_SUCCESS;
}

csi_status_t
csi_string_new (csi_t *ctx,
		csi_object_t *obj,
		const char *str,
		int len)
{
    csi_string_t *string;

    if (len < 0)
	len = strlen (str);
    if (_csi_unlikely (len >= INT_MAX))
	return _csi_error (CSI_STATUS_NO_MEMORY);

    if (ctx->free_string == NULL || ctx->free_string->len <= len) {
	string = _csi_slab_alloc (ctx, sizeof (csi_string_t));
	if (_csi_unlikely (string == NULL))
	    return _csi_error (CSI_STATUS_NO_MEMORY);

	string->string = _csi_alloc (ctx, len + 1);
	if (_csi_unlikely (string->string == NULL)) {
	    _csi_slab_free (ctx, string, sizeof (csi_string_t));
	    return _csi_error (CSI_STATUS_NO_MEMORY);
	}
    } else {
	string = ctx->free_string;
	ctx->free_string = NULL;
    }

    if (str != NULL) {
	memcpy (string->string, str, len);
	string->string[len] = '\0';
    }
    string->len = len;
    string->deflate = 0;
    string->method = NONE;

    string->base.type = CSI_OBJECT_TYPE_STRING;
    string->base.ref = 1;

    obj->type = CSI_OBJECT_TYPE_STRING;
    obj->datum.string = string;

    return CSI_STATUS_SUCCESS;
}

csi_status_t
csi_string_deflate_new (csi_t *ctx,
			csi_object_t *obj,
			void *bytes,
			int in_len,
			int out_len)
{
    csi_status_t status;
    csi_string_t *string;

    status = csi_string_new (ctx, obj, bytes, in_len);
    if (_csi_unlikely (status))
	return status;

    string = obj->datum.string;
    string->deflate = out_len;
    string->method = ZLIB;

    return CSI_STATUS_SUCCESS;
}

csi_status_t
csi_string_new_from_bytes (csi_t *ctx,
	                   csi_object_t *obj,
			   char *bytes,
			   unsigned int len)
{
    csi_string_t *string;

    if (_csi_unlikely (len >= INT_MAX))
	return _csi_error (CSI_STATUS_NO_MEMORY);

    string = _csi_slab_alloc (ctx, sizeof (csi_string_t));
    if (_csi_unlikely (string == NULL))
	return _csi_error (CSI_STATUS_NO_MEMORY);

    string->string = bytes;
    string->len = len;
    string->deflate = 0;
    string->method = NONE;

    string->base.type = CSI_OBJECT_TYPE_STRING;
    string->base.ref = 1;

    obj->type = CSI_OBJECT_TYPE_STRING;
    obj->datum.string = string;

    return CSI_STATUS_SUCCESS;
}

static inline csi_status_t
_csi_string_execute (csi_t *ctx, csi_string_t *string)
{
    csi_status_t status;
    csi_object_t obj;

    if (_csi_unlikely (string->len == 0))
	return CSI_STATUS_SUCCESS;

    status = csi_file_new_for_bytes (ctx, &obj, string->string, string->len);
    if (_csi_unlikely (status))
	return status;

    status = _csi_scan_file (ctx, obj.datum.file);
    csi_object_free (ctx, &obj);

    return status;
}

void
csi_string_free (csi_t *ctx, csi_string_t *string)
{
#if CSI_DEBUG_MALLOC
    _csi_free (ctx, string->string);
    _csi_slab_free (ctx, string, sizeof (csi_string_t));
#else
    if (ctx->free_string != NULL) {
	if (string->len > ctx->free_string->len) {
	    csi_string_t *tmp = ctx->free_string;
	    ctx->free_string = string;
	    string = tmp;
	}

	_csi_free (ctx, string->string);
	_csi_slab_free (ctx, string, sizeof (csi_string_t));
    } else
	ctx->free_string = string;
#endif
}

csi_status_t
csi_object_execute (csi_t *ctx, csi_object_t *obj)
{
    csi_status_t status;
    csi_object_t indirect;

 INDIRECT:
    switch (obj->type & CSI_OBJECT_TYPE_MASK) {
    case CSI_OBJECT_TYPE_NAME:
	status = _csi_name_lookup (ctx, obj->datum.name, &indirect);
	if (_csi_unlikely (status))
	    return status;
	if (indirect.type & CSI_OBJECT_ATTR_EXECUTABLE) {
	    obj = &indirect;
	    goto INDIRECT;
	} else
	    return _csi_push_ostack_copy (ctx, &indirect);

    case CSI_OBJECT_TYPE_OPERATOR:
	return obj->datum.op (ctx);

    case CSI_OBJECT_TYPE_ARRAY:
	return _csi_array_execute (ctx, obj->datum.array);
    case CSI_OBJECT_TYPE_FILE:
	return _csi_file_execute (ctx, obj->datum.file);
    case CSI_OBJECT_TYPE_STRING:
	return _csi_string_execute (ctx, obj->datum.string);

    default:
	return _csi_push_ostack_copy (ctx, obj);
    }
}

csi_object_t *
csi_object_reference (csi_object_t *obj)
{
    if (CSI_OBJECT_IS_CAIRO (obj)) {
	switch (obj->type & CSI_OBJECT_TYPE_MASK) {
	case CSI_OBJECT_TYPE_CONTEXT:
	    cairo_reference (obj->datum.cr);
	    break;
	case CSI_OBJECT_TYPE_FONT:
	    cairo_font_face_reference (obj->datum.font_face);
	    break;
	case CSI_OBJECT_TYPE_PATTERN:
	    cairo_pattern_reference (obj->datum.pattern);
	    break;
	case CSI_OBJECT_TYPE_SCALED_FONT:
	    cairo_scaled_font_reference (obj->datum.scaled_font);
	    break;
	case CSI_OBJECT_TYPE_SURFACE:
	    cairo_surface_reference (obj->datum.surface);
	    break;
	}
    } else if (CSI_OBJECT_IS_COMPOUND (obj)) {
	obj->datum.object->ref++;
    }

    return obj;
}

void
csi_object_free (csi_t *ctx,
		 csi_object_t *obj)
{
    if (CSI_OBJECT_IS_CAIRO (obj)) {
	switch (obj->type & CSI_OBJECT_TYPE_MASK) {
	case CSI_OBJECT_TYPE_CONTEXT:
	    cairo_destroy (obj->datum.cr);
	    break;
	case CSI_OBJECT_TYPE_FONT:
	    cairo_font_face_destroy (obj->datum.font_face);
	    break;
	case CSI_OBJECT_TYPE_PATTERN:
	    cairo_pattern_destroy (obj->datum.pattern);
	    break;
	case CSI_OBJECT_TYPE_SCALED_FONT:
	    cairo_scaled_font_destroy (obj->datum.scaled_font);
	    break;
	case CSI_OBJECT_TYPE_SURFACE:
	    cairo_surface_destroy (obj->datum.surface);
	    break;
	}
    } else if (CSI_OBJECT_IS_COMPOUND (obj)) {
	if (--obj->datum.object->ref)
	    return;

	switch (obj->type & CSI_OBJECT_TYPE_MASK) {
	case CSI_OBJECT_TYPE_ARRAY:
	    csi_array_free (ctx, obj->datum.array);
	    break;
	case CSI_OBJECT_TYPE_DICTIONARY:
	    csi_dictionary_free (ctx, obj->datum.dictionary);
	    break;
	case CSI_OBJECT_TYPE_FILE:
	    _csi_file_free (ctx, obj->datum.file);
	    break;
	case CSI_OBJECT_TYPE_MATRIX:
	    csi_matrix_free (ctx, obj->datum.matrix);
	    break;
	case CSI_OBJECT_TYPE_STRING:
	    csi_string_free (ctx, obj->datum.string);
	    break;
	default:
	    break;
	}
    }
}

csi_status_t
csi_object_as_file (csi_t *ctx,
		    csi_object_t *src,
		    csi_object_t *file)
{
    int type = csi_object_get_type (src);
    switch (type) {
    case CSI_OBJECT_TYPE_FILE:
	*file = *csi_object_reference (src);
	return CSI_STATUS_SUCCESS;
    case CSI_OBJECT_TYPE_STRING:
	 return csi_file_new_from_string (ctx, file, src->datum.string);
    case CSI_OBJECT_TYPE_ARRAY:
#if 0
	if (src->type & CSI_OBJECT_ATTR_EXECUTABLE)
	    return _csi_file_new_from_procedure (cs, src);
#endif
    default:
	return _csi_error (CSI_STATUS_INVALID_SCRIPT);
    }
}

static int
lexcmp (void const *a, size_t alen,
	void const *b, size_t blen)
{
    size_t len = alen < blen ? alen : blen;
    int cmp = memcmp (a, b, len);
    if (cmp)
	return cmp;
    if (alen == blen)
	return 0;
    return alen < blen ? -1 : +1;
}

csi_boolean_t
csi_object_eq (csi_object_t *a,
	       csi_object_t *b)
{
    csi_object_type_t atype = csi_object_get_type (a);
    csi_object_type_t btype = csi_object_get_type (b);

    if (atype == btype) {
	switch (atype) {
	case CSI_OBJECT_TYPE_BOOLEAN:
	    return a->datum.boolean == b->datum.boolean;
	case CSI_OBJECT_TYPE_INTEGER:
	    return a->datum.integer == b->datum.integer;
	case CSI_OBJECT_TYPE_REAL:
	    return a->datum.real == b->datum.real;
	case CSI_OBJECT_TYPE_NAME:
	    return a->datum.name == b->datum.name;
	case CSI_OBJECT_TYPE_STRING:
	    return 0 == lexcmp (a->datum.string->string,
				a->datum.string->len,
				b->datum.string->string,
				b->datum.string->len);
	case CSI_OBJECT_TYPE_NULL:
	case CSI_OBJECT_TYPE_MARK:
	    return TRUE;
	case CSI_OBJECT_TYPE_OPERATOR:
	    return a->datum.op == b->datum.op;
	case CSI_OBJECT_TYPE_ARRAY:
	case CSI_OBJECT_TYPE_DICTIONARY:
	case CSI_OBJECT_TYPE_FILE:
	case CSI_OBJECT_TYPE_MATRIX:
	case CSI_OBJECT_TYPE_CONTEXT:
	case CSI_OBJECT_TYPE_FONT:
	case CSI_OBJECT_TYPE_PATTERN:
	case CSI_OBJECT_TYPE_SCALED_FONT:
	case CSI_OBJECT_TYPE_SURFACE:
	    return a->datum.ptr == b->datum.ptr;
	}
    }

    if (atype < btype) {
	csi_object_t *c;
	csi_object_type_t ctype;
	c = a; a = b; b = c;
	ctype = atype; atype = btype; btype = ctype;
    }

    switch ((int) atype) {
    case CSI_OBJECT_TYPE_INTEGER:
	if (btype == CSI_OBJECT_TYPE_BOOLEAN) {
	    return a->datum.integer == b->datum.boolean;
	}
	break;
    case CSI_OBJECT_TYPE_REAL:
	if (btype == CSI_OBJECT_TYPE_INTEGER) {
	    return a->datum.real == b->datum.integer;
	}
	else if (btype == CSI_OBJECT_TYPE_BOOLEAN) {
	    return a->datum.real == b->datum.boolean;
	}
	break;

    case CSI_OBJECT_TYPE_STRING:
	if (btype == CSI_OBJECT_TYPE_NAME) {
	    const char *bstr = (const char *) b->datum.name;
	    return 0 == lexcmp (a->datum.string->string,
				a->datum.string->len,
				bstr,
				strlen (bstr));
	}
	break;

    default:
	break;
    }

    return FALSE;
}

csi_status_t
csi_object_compare (csi_object_t *a,
		    csi_object_t *b,
		    int *out)
{
    csi_object_type_t atype = csi_object_get_type (a);
    csi_object_type_t btype = csi_object_get_type (b);
    int sign;

    if (csi_object_eq (a, b)){
	*out = 0;
	return CSI_STATUS_SUCCESS;
    }

#define CMP(x,y) ((x) < (y) ? -1 : +1)

    if (atype == btype) {
	switch (atype) {
	case CSI_OBJECT_TYPE_BOOLEAN:
	    *out = CMP (a->datum.boolean, b->datum.boolean);
	    return CSI_STATUS_SUCCESS;
	case CSI_OBJECT_TYPE_INTEGER:
	    *out = CMP (a->datum.integer, b->datum.integer);
	    return CSI_STATUS_SUCCESS;
	case CSI_OBJECT_TYPE_REAL:
	    *out = CMP (a->datum.real, b->datum.real);
	    return CSI_STATUS_SUCCESS;
	case CSI_OBJECT_TYPE_NAME: {
	    const char *x = (char const *) a->datum.name;
	    const char *y = (char const *) b->datum.name;
	    *out = lexcmp (x, strlen(x), y, strlen (y));
	    return CSI_STATUS_SUCCESS;
	}
	case CSI_OBJECT_TYPE_STRING:
	    *out = lexcmp (a->datum.string->string,
			   a->datum.string->len,
			   b->datum.string->string,
			   b->datum.string->len);
	    return CSI_STATUS_SUCCESS;
	case CSI_OBJECT_TYPE_NULL:
	case CSI_OBJECT_TYPE_MARK:
	case CSI_OBJECT_TYPE_OPERATOR:
	case CSI_OBJECT_TYPE_ARRAY:
	case CSI_OBJECT_TYPE_DICTIONARY:
	case CSI_OBJECT_TYPE_FILE:
	case CSI_OBJECT_TYPE_MATRIX:
	case CSI_OBJECT_TYPE_CONTEXT:
	case CSI_OBJECT_TYPE_FONT:
	case CSI_OBJECT_TYPE_PATTERN:
	case CSI_OBJECT_TYPE_SCALED_FONT:
	case CSI_OBJECT_TYPE_SURFACE:
	    goto TYPE_CHECK_ERROR;
	}
    }

    sign = +1;
    if (atype < btype) {
	csi_object_t *c;
	csi_object_type_t ctype;
	c = a; a = b; b = c;
	ctype = atype; atype = btype; btype = ctype;
	sign = -1;
    }

    switch ((int) atype) {
    case CSI_OBJECT_TYPE_INTEGER:
	if (btype == CSI_OBJECT_TYPE_BOOLEAN) {
	    *out = sign * CMP (a->datum.integer, !!b->datum.boolean);
	    return CSI_STATUS_SUCCESS;
	}
	break;
    case CSI_OBJECT_TYPE_REAL:
	if (btype == CSI_OBJECT_TYPE_INTEGER) {
	    *out = sign * CMP (a->datum.real, b->datum.integer);
	    return CSI_STATUS_SUCCESS;
	}
	else if (btype == CSI_OBJECT_TYPE_BOOLEAN) {
	    *out = sign * CMP (a->datum.real, !!b->datum.boolean);
	    return CSI_STATUS_SUCCESS;
	}
	break;

    case CSI_OBJECT_TYPE_STRING:
	if (btype == CSI_OBJECT_TYPE_NAME) {
	    const char *bstr = (const char *) b->datum.name;
	    *out = sign * lexcmp (a->datum.string->string,
				  a->datum.string->len,
				  bstr,
				  strlen (bstr));
	    return CSI_STATUS_SUCCESS;
	}
	break;

    default:
	break;
    }

#undef CMP

 TYPE_CHECK_ERROR:
    return _csi_error (CSI_STATUS_SCRIPT_INVALID_TYPE);
}