[babeltrace.git] / types / integer.c

/*
 * integer.c
 *
 * BabelTrace - Integer Type Converter
 *
 * Copyright 2010, 2011 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
 *
 * 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 the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, 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 shall be included in
 * all copies or substantial portions of the Software.
 */

#include <babeltrace/compiler.h>
#include <babeltrace/align.h>
#include <babeltrace/format.h>
#include <stdint.h>

static
struct declaration *_integer_declaration_new(struct type *type,
			       struct declaration_scope *parent_scope);
static
void _integer_declaration_free(struct declaration *declaration);

void integer_copy(struct stream_pos *dest, const struct format *fdest, 
		  struct stream_pos *src, const struct format *fsrc,
		  struct declaration *declaration)
{
	struct declaration_integer *integer =
		container_of(declaration, struct declaration_integer, p);
	struct type_integer *integer_type = integer->type;

	if (!integer_type->signedness) {
		uint64_t v;

		v = fsrc->uint_read(src, integer_type);
		fdest->uint_write(dest, integer_type, v);
	} else {
		int64_t v;

		v = fsrc->int_read(src, integer_type);
		fdest->int_write(dest, integer_type, v);
	}
}

static
void _integer_type_free(struct type *type)
{
	struct type_integer *integer_type =
		container_of(type, struct type_integer, p);
	g_free(integer_type);
}

struct type_integer *
	integer_type_new(const char *name, size_t len, int byte_order,
			 int signedness, size_t alignment)
{
	struct type_integer *integer_type;

	integer_type = g_new(struct type_integer, 1);
	integer_type->p.name = g_quark_from_string(name);
	integer_type->p.alignment = alignment;
	integer_type->p.copy = integer_copy;
	integer_type->p.type_free = _integer_type_free;
	integer_type->p.declaration_free = _integer_declaration_free;
	integer_type->p.declaration_new = _integer_declaration_new;
	integer_type->p.ref = 1;
	integer_type->len = len;
	integer_type->byte_order = byte_order;
	integer_type->signedness = signedness;
	return integer_type;
}

static
struct declaration *
	_integer_declaration_new(struct type *type,
				 struct declaration_scope *parent_scope)
{
	struct type_integer *integer_type =
		container_of(type, struct type_integer, p);
	struct declaration_integer *integer;

	integer = g_new(struct declaration_integer, 1);
	type_ref(&integer_type->p);
	integer->p.type = type;
	integer->type = integer_type;
	integer->p.ref = 1;
	integer->value._unsigned = 0;
	return &integer->p;
}

static
void _integer_declaration_free(struct declaration *declaration)
{
	struct declaration_integer *integer =
		container_of(declaration, struct declaration_integer, p);

	type_unref(integer->p.type);
	g_free(integer);
}
Commit	Line	Data
	1	/*
	2	* integer.c
	3	*
	4	* BabelTrace - Integer Type Converter
	5	*
	6	* Copyright 2010, 2011 - Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
	7	*
	8	* Permission is hereby granted, free of charge, to any person obtaining a copy
	9	* of this software and associated documentation files (the "Software"), to deal
	10	* in the Software without restriction, including without limitation the rights
	11	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	12	* copies of the Software, and to permit persons to whom the Software is
	13	* furnished to do so, subject to the following conditions:
	14	*
	15	* The above copyright notice and this permission notice shall be included in
	16	* all copies or substantial portions of the Software.
	17	*/
	18
	19	#include <babeltrace/compiler.h>
	20	#include <babeltrace/align.h>
	21	#include <babeltrace/format.h>
	22	#include <stdint.h>
	23
	24	static
	25	struct declaration _integer_declaration_new(struct type type,
	26	struct declaration_scope *parent_scope);
	27	static
	28	void _integer_declaration_free(struct declaration *declaration);
	29
	30	void integer_copy(struct stream_pos dest, const struct format fdest,
	31	struct stream_pos src, const struct format fsrc,
	32	struct declaration *declaration)
	33	{
	34	struct declaration_integer *integer =
	35	container_of(declaration, struct declaration_integer, p);
	36	struct type_integer *integer_type = integer->type;
	37
	38	if (!integer_type->signedness) {
	39	uint64_t v;
	40
	41	v = fsrc->uint_read(src, integer_type);
	42	fdest->uint_write(dest, integer_type, v);
	43	} else {
	44	int64_t v;
	45
	46	v = fsrc->int_read(src, integer_type);
	47	fdest->int_write(dest, integer_type, v);
	48	}
	49	}
	50
	51	static
	52	void _integer_type_free(struct type *type)
	53	{
	54	struct type_integer *integer_type =
	55	container_of(type, struct type_integer, p);
	56	g_free(integer_type);
	57	}
	58
	59	struct type_integer *
	60	integer_type_new(const char *name, size_t len, int byte_order,
	61	int signedness, size_t alignment)
	62	{
	63	struct type_integer *integer_type;
	64
	65	integer_type = g_new(struct type_integer, 1);
	66	integer_type->p.name = g_quark_from_string(name);
	67	integer_type->p.alignment = alignment;
	68	integer_type->p.copy = integer_copy;
	69	integer_type->p.type_free = _integer_type_free;
	70	integer_type->p.declaration_free = _integer_declaration_free;
	71	integer_type->p.declaration_new = _integer_declaration_new;
	72	integer_type->p.ref = 1;
	73	integer_type->len = len;
	74	integer_type->byte_order = byte_order;
	75	integer_type->signedness = signedness;
	76	return integer_type;
	77	}
	78
	79	static
	80	struct declaration *
	81	_integer_declaration_new(struct type *type,
	82	struct declaration_scope *parent_scope)
	83	{
	84	struct type_integer *integer_type =
	85	container_of(type, struct type_integer, p);
	86	struct declaration_integer *integer;
	87
	88	integer = g_new(struct declaration_integer, 1);
	89	type_ref(&integer_type->p);
	90	integer->p.type = type;
	91	integer->type = integer_type;
	92	integer->p.ref = 1;
	93	integer->value._unsigned = 0;
	94	return &integer->p;
	95	}
	96
	97	static
	98	void _integer_declaration_free(struct declaration *declaration)
	99	{
	100	struct declaration_integer *integer =
	101	container_of(declaration, struct declaration_integer, p);
	102
	103	type_unref(integer->p.type);
	104	g_free(integer);
	105	}