[linux.git] / scripts / dtc / data.c

/*
 * (C) Copyright David Gibson <[email protected]>, IBM Corporation.  2005.
 *
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 *                                                                   USA
 */

#include "dtc.h"

void data_free(struct data d)
{
	struct marker *m, *nm;

	m = d.markers;
	while (m) {
		nm = m->next;
		free(m->ref);
		free(m);
		m = nm;
	}

	if (d.val)
		free(d.val);
}

struct data data_grow_for(struct data d, int xlen)
{
	struct data nd;
	int newsize;

	if (xlen == 0)
		return d;

	nd = d;

	newsize = xlen;

	while ((d.len + xlen) > newsize)
		newsize *= 2;

	nd.val = xrealloc(d.val, newsize);

	return nd;
}

struct data data_copy_mem(const char *mem, int len)
{
	struct data d;

	d = data_grow_for(empty_data, len);

	d.len = len;
	memcpy(d.val, mem, len);

	return d;
}

static char get_oct_char(const char *s, int *i)
{
	char x[4];
	char *endx;
	long val;

	x[3] = '\0';
	strncpy(x, s + *i, 3);

	val = strtol(x, &endx, 8);

	assert(endx > x);

	(*i) += endx - x;
	return val;
}

static char get_hex_char(const char *s, int *i)
{
	char x[3];
	char *endx;
	long val;

	x[2] = '\0';
	strncpy(x, s + *i, 2);

	val = strtol(x, &endx, 16);
	if (!(endx  > x))
		die("\\x used with no following hex digits\n");

	(*i) += endx - x;
	return val;
}

struct data data_copy_escape_string(const char *s, int len)
{
	int i = 0;
	struct data d;
	char *q;

	d = data_grow_for(empty_data, strlen(s)+1);

	q = d.val;
	while (i < len) {
		char c = s[i++];

		if (c != '\\') {
			q[d.len++] = c;
			continue;
		}

		c = s[i++];
		assert(c);
		switch (c) {
		case 'a':
			q[d.len++] = '\a';
			break;
		case 'b':
			q[d.len++] = '\b';
			break;
		case 't':
			q[d.len++] = '\t';
			break;
		case 'n':
			q[d.len++] = '\n';
			break;
		case 'v':
			q[d.len++] = '\v';
			break;
		case 'f':
			q[d.len++] = '\f';
			break;
		case 'r':
			q[d.len++] = '\r';
			break;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
			i--; /* need to re-read the first digit as
			      * part of the octal value */
			q[d.len++] = get_oct_char(s, &i);
			break;
		case 'x':
			q[d.len++] = get_hex_char(s, &i);
			break;
		default:
			q[d.len++] = c;
		}
	}

	q[d.len++] = '\0';
	return d;
}

struct data data_copy_file(FILE *f, size_t maxlen)
{
	struct data d = empty_data;

	while (!feof(f) && (d.len < maxlen)) {
		size_t chunksize, ret;

		if (maxlen == -1)
			chunksize = 4096;
		else
			chunksize = maxlen - d.len;

		d = data_grow_for(d, chunksize);
		ret = fread(d.val + d.len, 1, chunksize, f);

		if (ferror(f))
			die("Error reading file into data: %s", strerror(errno));

		if (d.len + ret < d.len)
			die("Overflow reading file into data\n");

		d.len += ret;
	}

	return d;
}

struct data data_append_data(struct data d, const void *p, int len)
{
	d = data_grow_for(d, len);
	memcpy(d.val + d.len, p, len);
	d.len += len;
	return d;
}

struct data data_insert_at_marker(struct data d, struct marker *m,
				  const void *p, int len)
{
	d = data_grow_for(d, len);
	memmove(d.val + m->offset + len, d.val + m->offset, d.len - m->offset);
	memcpy(d.val + m->offset, p, len);
	d.len += len;

	/* Adjust all markers after the one we're inserting at */
	m = m->next;
	for_each_marker(m)
		m->offset += len;
	return d;
}

static struct data data_append_markers(struct data d, struct marker *m)
{
	struct marker **mp = &d.markers;

	/* Find the end of the markerlist */
	while (*mp)
		mp = &((*mp)->next);
	*mp = m;
	return d;
}

struct data data_merge(struct data d1, struct data d2)
{
	struct data d;
	struct marker *m2 = d2.markers;

	d = data_append_markers(data_append_data(d1, d2.val, d2.len), m2);

	/* Adjust for the length of d1 */
	for_each_marker(m2)
		m2->offset += d1.len;

	d2.markers = NULL; /* So data_free() doesn't clobber them */
	data_free(d2);

	return d;
}

struct data data_append_cell(struct data d, cell_t word)
{
	cell_t beword = cpu_to_fdt32(word);

	return data_append_data(d, &beword, sizeof(beword));
}

struct data data_append_re(struct data d, const struct fdt_reserve_entry *re)
{
	struct fdt_reserve_entry bere;

	bere.address = cpu_to_fdt64(re->address);
	bere.size = cpu_to_fdt64(re->size);

	return data_append_data(d, &bere, sizeof(bere));
}

struct data data_append_addr(struct data d, uint64_t addr)
{
	uint64_t beaddr = cpu_to_fdt64(addr);

	return data_append_data(d, &beaddr, sizeof(beaddr));
}

struct data data_append_byte(struct data d, uint8_t byte)
{
	return data_append_data(d, &byte, 1);
}

struct data data_append_zeroes(struct data d, int len)
{
	d = data_grow_for(d, len);

	memset(d.val + d.len, 0, len);
	d.len += len;
	return d;
}

struct data data_append_align(struct data d, int align)
{
	int newlen = ALIGN(d.len, align);
	return data_append_zeroes(d, newlen - d.len);
}

struct data data_add_marker(struct data d, enum markertype type, char *ref)
{
	struct marker *m;

	m = xmalloc(sizeof(*m));
	m->offset = d.len;
	m->type = type;
	m->ref = ref;
	m->next = NULL;

	return data_append_markers(d, m);
}

int data_is_one_string(struct data d)
{
	int i;
	int len = d.len;

	if (len == 0)
		return 0;

	for (i = 0; i < len-1; i++)
		if (d.val[i] == '\0')
			return 0;

	if (d.val[len-1] != '\0')
		return 0;

	return 1;
}
Commit	Line	Data
a4da2e3e DG	1	/*
	2	* (C) Copyright David Gibson <[email protected]>, IBM Corporation. 2005.
	3	*
	4	*
	5	* This program is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU General Public License as
	7	* published by the Free Software Foundation; either version 2 of the
	8	* License, or (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this program; if not, write to the Free Software
	17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
	18	* USA
	19	*/
	20
	21	#include "dtc.h"
	22
	23	void data_free(struct data d)
	24	{
	25	struct marker m, nm;
	26
	27	m = d.markers;
	28	while (m) {
	29	nm = m->next;
	30	free(m->ref);
	31	free(m);
	32	m = nm;
	33	}
	34
a4da2e3e DG	35	if (d.val)
	36	free(d.val);
	37	}
	38
	39	struct data data_grow_for(struct data d, int xlen)
	40	{
	41	struct data nd;
	42	int newsize;
	43
a4da2e3e DG	44	if (xlen == 0)
	45	return d;
	46
	47	nd = d;
	48
	49	newsize = xlen;
	50
	51	while ((d.len + xlen) > newsize)
	52	newsize *= 2;
	53
a4da2e3e DG	54	nd.val = xrealloc(d.val, newsize);
a4da2e3e DG	55
a4da2e3e DG	56	return nd;
	57	}
	58
	59	struct data data_copy_mem(const char *mem, int len)
	60	{
	61	struct data d;
	62
	63	d = data_grow_for(empty_data, len);
	64
	65	d.len = len;
	66	memcpy(d.val, mem, len);
	67
	68	return d;
	69	}
	70
	71	static char get_oct_char(const char s, int i)
	72	{
	73	char x[4];
	74	char *endx;
	75	long val;
	76
	77	x[3] = '\0';
ed95d745	78	strncpy(x, s + *i, 3);
a4da2e3e DG	79
a4da2e3e DG	80	val = strtol(x, &endx, 8);
ed95d745 DG	81
ed95d745 DG	82	assert(endx > x);
a4da2e3e DG	83
	84	(*i) += endx - x;
	85	return val;
	86	}
	87
	88	static char get_hex_char(const char s, int i)
	89	{
	90	char x[3];
	91	char *endx;
	92	long val;
	93
	94	x[2] = '\0';
ed95d745	95	strncpy(x, s + *i, 2);
a4da2e3e DG	96
a4da2e3e DG	97	val = strtol(x, &endx, 16);
ed95d745 DG	98	if (!(endx > x))
ed95d745 DG	99	die("\\x used with no following hex digits\n");
a4da2e3e DG	100
	101	(*i) += endx - x;
	102	return val;
	103	}
	104
	105	struct data data_copy_escape_string(const char *s, int len)
	106	{
	107	int i = 0;
	108	struct data d;
	109	char *q;
	110
	111	d = data_grow_for(empty_data, strlen(s)+1);
	112
	113	q = d.val;
	114	while (i < len) {
	115	char c = s[i++];
	116
	117	if (c != '\\') {
	118	q[d.len++] = c;
	119	continue;
	120	}
	121
	122	c = s[i++];
	123	assert(c);
	124	switch (c) {
	125	case 'a':
	126	q[d.len++] = '\a';
	127	break;
	128	case 'b':
	129	q[d.len++] = '\b';
	130	break;
	131	case 't':
	132	q[d.len++] = '\t';
	133	break;
	134	case 'n':
	135	q[d.len++] = '\n';
	136	break;
	137	case 'v':
	138	q[d.len++] = '\v';
	139	break;
	140	case 'f':
	141	q[d.len++] = '\f';
	142	break;
	143	case 'r':
	144	q[d.len++] = '\r';
	145	break;
	146	case '0':
	147	case '1':
	148	case '2':
	149	case '3':
	150	case '4':
	151	case '5':
	152	case '6':
	153	case '7':
	154	i--; /* need to re-read the first digit as
	155	* part of the octal value */
	156	q[d.len++] = get_oct_char(s, &i);
	157	break;
	158	case 'x':
	159	q[d.len++] = get_hex_char(s, &i);
	160	break;
	161	default:
	162	q[d.len++] = c;
	163	}
164	}
165
166	q[d.len++] = '\0';
167	return d;
168	}
169
ed95d745	170	struct data data_copy_file(FILE *f, size_t maxlen)
a4da2e3e	171	{
ed95d745	172	struct data d = empty_data;
a4da2e3e	173
ed95d745 DG	174	while (!feof(f) && (d.len < maxlen)) {
ed95d745 DG	175	size_t chunksize, ret;
a4da2e3e	176
ed95d745 DG	177	if (maxlen == -1)
	178	chunksize = 4096;
	179	else
	180	chunksize = maxlen - d.len;
	181
	182	d = data_grow_for(d, chunksize);
	183	ret = fread(d.val + d.len, 1, chunksize, f);
	184
	185	if (ferror(f))
	186	die("Error reading file into data: %s", strerror(errno));
	187
	188	if (d.len + ret < d.len)
	189	die("Overflow reading file into data\n");
	190
	191	d.len += ret;
	192	}
a4da2e3e DG	193
	194	return d;
	195	}
	196
	197	struct data data_append_data(struct data d, const void *p, int len)
	198	{
	199	d = data_grow_for(d, len);
	200	memcpy(d.val + d.len, p, len);
	201	d.len += len;
	202	return d;
	203	}
	204
	205	struct data data_insert_at_marker(struct data d, struct marker *m,
	206	const void *p, int len)
	207	{
	208	d = data_grow_for(d, len);
	209	memmove(d.val + m->offset + len, d.val + m->offset, d.len - m->offset);
	210	memcpy(d.val + m->offset, p, len);
	211	d.len += len;
	212
	213	/* Adjust all markers after the one we're inserting at */
	214	m = m->next;
	215	for_each_marker(m)
	216	m->offset += len;
	217	return d;
	218	}
	219
5ccd9915	220	static struct data data_append_markers(struct data d, struct marker *m)
a4da2e3e DG	221	{
	222	struct marker **mp = &d.markers;
	223
	224	/* Find the end of the markerlist */
	225	while (*mp)
	226	mp = &((*mp)->next);
	227	*mp = m;
	228	return d;
	229	}
	230
	231	struct data data_merge(struct data d1, struct data d2)
	232	{
	233	struct data d;
	234	struct marker *m2 = d2.markers;
	235
	236	d = data_append_markers(data_append_data(d1, d2.val, d2.len), m2);
	237
	238	/* Adjust for the length of d1 */
	239	for_each_marker(m2)
	240	m2->offset += d1.len;
	241
	242	d2.markers = NULL; /* So data_free() doesn't clobber them */
	243	data_free(d2);
	244
	245	return d;
	246	}
	247
	248	struct data data_append_cell(struct data d, cell_t word)
	249	{
ed95d745	250	cell_t beword = cpu_to_fdt32(word);
a4da2e3e DG	251
	252	return data_append_data(d, &beword, sizeof(beword));
	253	}
	254
	255	struct data data_append_re(struct data d, const struct fdt_reserve_entry *re)
	256	{
	257	struct fdt_reserve_entry bere;
	258
ed95d745 DG	259	bere.address = cpu_to_fdt64(re->address);
ed95d745 DG	260	bere.size = cpu_to_fdt64(re->size);
a4da2e3e DG	261
	262	return data_append_data(d, &bere, sizeof(bere));
	263	}
	264
ed95d745	265	struct data data_append_addr(struct data d, uint64_t addr)
a4da2e3e	266	{
ed95d745	267	uint64_t beaddr = cpu_to_fdt64(addr);
a4da2e3e DG	268
	269	return data_append_data(d, &beaddr, sizeof(beaddr));
	270	}
	271
	272	struct data data_append_byte(struct data d, uint8_t byte)
	273	{
	274	return data_append_data(d, &byte, 1);
	275	}
	276
	277	struct data data_append_zeroes(struct data d, int len)
	278	{
	279	d = data_grow_for(d, len);
	280
	281	memset(d.val + d.len, 0, len);
	282	d.len += len;
	283	return d;
	284	}
	285
	286	struct data data_append_align(struct data d, int align)
	287	{
	288	int newlen = ALIGN(d.len, align);
	289	return data_append_zeroes(d, newlen - d.len);
	290	}
	291
	292	struct data data_add_marker(struct data d, enum markertype type, char *ref)
	293	{
	294	struct marker *m;
	295
	296	m = xmalloc(sizeof(*m));
	297	m->offset = d.len;
	298	m->type = type;
	299	m->ref = ref;
	300	m->next = NULL;
	301
	302	return data_append_markers(d, m);
	303	}
	304
	305	int data_is_one_string(struct data d)
	306	{
	307	int i;
	308	int len = d.len;
	309
	310	if (len == 0)
	311	return 0;
	312
	313	for (i = 0; i < len-1; i++)
	314	if (d.val[i] == '\0')
	315	return 0;
	316
	317	if (d.val[len-1] != '\0')
	318	return 0;
	319
	320	return 1;
	321	}