/* * (C) Copyright David Gibson <dwg@au1.ibm.com>, 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;} 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;}