radeon/bof.c

/*
 * Copyright 2010 Jerome Glisse <glisse@freedesktop.org>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * on the rights to use, copy, modify, merge, publish, distribute, sub
 * license, and/or sell copies of the Software, and to permit persons to whom
 * the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 * USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * Authors:
 *      Jerome Glisse
 */
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "bof.h"

/*
 * helpers
 */
static int bof_entry_grow(bof_t *bof)
{
	bof_t **array;

	if (bof->array_size < bof->nentry)
		return 0;
	array = realloc(bof->array, (bof->nentry + 16) * sizeof(void*));
	if (array == NULL)
		return -ENOMEM;
	bof->array = array;
	bof->nentry += 16;
	return 0;
}

/*
 * object 
 */
bof_t *bof_object(void)
{
	bof_t *object;

	object = calloc(1, sizeof(bof_t));
	if (object == NULL)
		return NULL;
	object->refcount = 1;
	object->type = BOF_TYPE_OBJECT;
	object->size = 12;
	return object;
}

bof_t *bof_object_get(bof_t *object, const char *keyname)
{
	unsigned i;

	for (i = 0; i < object->array_size; i += 2) {
		if (!strcmp(object->array[i]->value, keyname)) {
			return object->array[i + 1];
		}
	}
	return NULL;
}

int bof_object_set(bof_t *object, const char *keyname, bof_t *value)
{
	bof_t *key;
	int r;

	if (object->type != BOF_TYPE_OBJECT)
		return -EINVAL;
	r = bof_entry_grow(object);
	if (r)
		return r;
	key = bof_string(keyname);
	if (key == NULL)
		return -ENOMEM;
	object->array[object->array_size++] = key;
	object->array[object->array_size++] = value;
	object->size += value->size;
	object->size += key->size;
	bof_incref(value);
	return 0;
}

/*
 * array
 */
bof_t *bof_array(void)
{
	bof_t *array = bof_object();

	if (array == NULL)
		return NULL;
	array->type = BOF_TYPE_ARRAY;
	array->size = 12;
	return array;
}

int bof_array_append(bof_t *array, bof_t *value)
{
	int r;
	if (array->type != BOF_TYPE_ARRAY)
		return -EINVAL;
	r = bof_entry_grow(array);
	if (r)
		return r;
	array->array[array->array_size++] = value;
	array->size += value->size;
	bof_incref(value);
	return 0;
}

bof_t *bof_array_get(bof_t *bof, unsigned i)
{
	if (!bof_is_array(bof) || i >= bof->array_size)
		return NULL;
	return bof->array[i];
}

unsigned bof_array_size(bof_t *bof)
{
	if (!bof_is_array(bof))
		return 0;
	return bof->array_size;
}

/*
 * blob
 */
bof_t *bof_blob(unsigned size, void *value)
{
	bof_t *blob = bof_object();

	if (blob == NULL)
		return NULL;
	blob->type = BOF_TYPE_BLOB;
	blob->value = calloc(1, size);
	if (blob->value == NULL) {
		bof_decref(blob);
		return NULL;
	}
	blob->size = size;
	memcpy(blob->value, value, size);
	blob->size += 12;
	return blob;
}

unsigned bof_blob_size(bof_t *bof)
{
	if (!bof_is_blob(bof))
		return 0;
	return bof->size - 12;
}

void *bof_blob_value(bof_t *bof)
{
	if (!bof_is_blob(bof))
		return NULL;
	return bof->value;
}

/*
 * string
 */
bof_t *bof_string(const char *value)
{
	bof_t *string = bof_object();

	if (string == NULL)
		return NULL;
	string->type = BOF_TYPE_STRING;
	string->size = strlen(value) + 1;
	string->value = calloc(1, string->size);
	if (string->value == NULL) {
		bof_decref(string);
		return NULL;
	}
	strcpy(string->value, value);
	string->size += 12;
	return string;
}

/*
 *  int32
 */
bof_t *bof_int32(int32_t value)
{
	bof_t *int32 = bof_object();

	if (int32 == NULL)
		return NULL;
	int32->type = BOF_TYPE_INT32;
	int32->size = 4;
	int32->value = calloc(1, int32->size);
	if (int32->value == NULL) {
		bof_decref(int32);
		return NULL;
	}
	memcpy(int32->value, &value, 4);
	int32->size += 12;
	return int32;
}

int32_t bof_int32_value(bof_t *bof)
{
	return *((uint32_t*)bof->value);
}

/*
 *  common
 */
static void bof_indent(int level)
{
	int i;

	for (i = 0; i < level; i++)
		fprintf(stderr, " ");
}

static void bof_print_bof(bof_t *bof, int level, int entry)
{
	bof_indent(level);
	if (bof == NULL) {
		fprintf(stderr, "--NULL-- for entry %d\n", entry);
		return;
	}
	switch (bof->type) {
	case BOF_TYPE_STRING:
		fprintf(stderr, "%p string [%s %d]\n", bof, (char*)bof->value, bof->size);
		break;
	case BOF_TYPE_INT32:
		fprintf(stderr, "%p int32 [%d %d]\n", bof, *(int*)bof->value, bof->size);
		break;
	case BOF_TYPE_BLOB:
		fprintf(stderr, "%p blob [%d]\n", bof, bof->size);
		break;
	case BOF_TYPE_NULL:
		fprintf(stderr, "%p null [%d]\n", bof, bof->size);
		break;
	case BOF_TYPE_OBJECT:
		fprintf(stderr, "%p object [%d %d]\n", bof, bof->array_size / 2, bof->size);
		break;
	case BOF_TYPE_ARRAY:
		fprintf(stderr, "%p array [%d %d]\n", bof, bof->array_size, bof->size);
		break;
	default:
		fprintf(stderr, "%p unknown [%d]\n", bof, bof->type);
		return;
	}
}

static void bof_print_rec(bof_t *bof, int level, int entry)
{
	unsigned i;

	bof_print_bof(bof, level, entry);
	for (i = 0; i < bof->array_size; i++) {
		bof_print_rec(bof->array[i], level + 2, i);
	}
}

void bof_print(bof_t *bof)
{
	bof_print_rec(bof, 0, 0);
}

static int bof_read(bof_t *root, FILE *file, long end, int level)
{
	bof_t *bof = NULL;
	int r;

	if (ftell(file) >= end) {
		return 0;
	}
	r = bof_entry_grow(root);
	if (r)
		return r;
	bof = bof_object();
	if (bof == NULL)
		return -ENOMEM;
	bof->offset = ftell(file);
	r = fread(&bof->type, 4, 1, file);
	if (r != 1)
		goto out_err;
	r = fread(&bof->size, 4, 1, file);
	if (r != 1)
		goto out_err;
	r = fread(&bof->array_size, 4, 1, file);
	if (r != 1)
		goto out_err;
	switch (bof->type) {
	case BOF_TYPE_STRING:
	case BOF_TYPE_INT32:
	case BOF_TYPE_BLOB:
		bof->value = calloc(1, bof->size - 12);
		if (bof->value == NULL) {
			goto out_err;
		}
		r = fread(bof->value, bof->size - 12, 1, file);
		if (r != 1) {
			fprintf(stderr, "error reading %d\n", bof->size - 12);
			goto out_err;
		}
		break;
	case BOF_TYPE_NULL:
		return 0;
	case BOF_TYPE_OBJECT:
	case BOF_TYPE_ARRAY:
		r = bof_read(bof, file, bof->offset + bof->size, level + 2);
		if (r)
			goto out_err;
		break;
	default:
		fprintf(stderr, "invalid type %d\n", bof->type);
		goto out_err;
	}
	root->array[root->centry++] = bof;
	return bof_read(root, file, end, level);
out_err:
	bof_decref(bof);
	return -EINVAL;
}

bof_t *bof_load_file(const char *filename)
{
	bof_t *root = bof_object();
	int r;

	if (root == NULL) {
		fprintf(stderr, "%s failed to create root object\n", __func__);
		return NULL;
	}
	root->file = fopen(filename, "r");
	if (root->file == NULL)
		goto out_err;
	r = fseek(root->file, 0L, SEEK_SET);
	if (r) {
		fprintf(stderr, "%s failed to seek into file %s\n", __func__, filename);
		goto out_err;
	}
	root->offset = ftell(root->file);
	r = fread(&root->type, 4, 1, root->file);
	if (r != 1)
		goto out_err;
	r = fread(&root->size, 4, 1, root->file);
	if (r != 1)
		goto out_err;
	r = fread(&root->array_size, 4, 1, root->file);
	if (r != 1)
		goto out_err;
	r = bof_read(root, root->file, root->offset + root->size, 2);
	if (r)
		goto out_err;
	return root;
out_err:
	bof_decref(root);
	return NULL;
}

void bof_incref(bof_t *bof)
{
	bof->refcount++;
}

void bof_decref(bof_t *bof)
{
	unsigned i;

	if (bof == NULL)
		return;
	if (--bof->refcount > 0)
		return;
	for (i = 0; i < bof->array_size; i++) {
		bof_decref(bof->array[i]);
		bof->array[i] = NULL;
	}
	bof->array_size = 0;
	if (bof->file) {
		fclose(bof->file);
		bof->file = NULL;
	}
	free(bof->array);
	free(bof->value);
	free(bof);
}

static int bof_file_write(bof_t *bof, FILE *file)
{
	unsigned i;
	int r;

	r = fwrite(&bof->type, 4, 1, file);
	if (r != 1)
		return -EINVAL;
	r = fwrite(&bof->size, 4, 1, file);
	if (r != 1)
		return -EINVAL;
	r = fwrite(&bof->array_size, 4, 1, file);
	if (r != 1)
		return -EINVAL;
	switch (bof->type) {
	case BOF_TYPE_NULL:
		if (bof->size)
			return -EINVAL;
		break;
	case BOF_TYPE_STRING:
	case BOF_TYPE_INT32:
	case BOF_TYPE_BLOB:
		r = fwrite(bof->value, bof->size - 12, 1, file);
		if (r != 1)
			return -EINVAL;
		break;
	case BOF_TYPE_OBJECT:
	case BOF_TYPE_ARRAY:
		for (i = 0; i < bof->array_size; i++) {
			r = bof_file_write(bof->array[i], file);
			if (r)
				return r;
		}
		break;
	default:
		return -EINVAL;
	}
	return 0;
}

int bof_dump_file(bof_t *bof, const char *filename)
{
	unsigned i;
	int r = 0;

	if (bof->file) {
		fclose(bof->file);
		bof->file = NULL;
	}
	bof->file = fopen(filename, "w");
	if (bof->file == NULL) {
		fprintf(stderr, "%s failed to open file %s\n", __func__, filename);
		r = -EINVAL;
		goto out_err;
	}
	r = fseek(bof->file, 0L, SEEK_SET);
	if (r) {
		fprintf(stderr, "%s failed to seek into file %s\n", __func__, filename);
		goto out_err;
	}
	r = fwrite(&bof->type, 4, 1, bof->file);
	if (r != 1)
		goto out_err;
	r = fwrite(&bof->size, 4, 1, bof->file);
	if (r != 1)
		goto out_err;
	r = fwrite(&bof->array_size, 4, 1, bof->file);
	if (r != 1)
		goto out_err;
	for (i = 0; i < bof->array_size; i++) {
		r = bof_file_write(bof->array[i], bof->file);
		if (r)
			return r;
	}
out_err:
	fclose(bof->file);
	bof->file = NULL;
	return r;
}