270 lines
5.1 KiB
C
Executable File
270 lines
5.1 KiB
C
Executable File
/*
|
|
* (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;
|
|
}
|
|
|
|
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 == '\\')
|
|
c = get_escape_char(s, &i);
|
|
|
|
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_integer(struct data d, uint64_t value, int bits)
|
|
{
|
|
uint8_t value_8;
|
|
uint16_t value_16;
|
|
uint32_t value_32;
|
|
uint64_t value_64;
|
|
|
|
switch (bits) {
|
|
case 8:
|
|
value_8 = value;
|
|
return data_append_data(d, &value_8, 1);
|
|
|
|
case 16:
|
|
value_16 = cpu_to_fdt16(value);
|
|
return data_append_data(d, &value_16, 2);
|
|
|
|
case 32:
|
|
value_32 = cpu_to_fdt32(value);
|
|
return data_append_data(d, &value_32, 4);
|
|
|
|
case 64:
|
|
value_64 = cpu_to_fdt64(value);
|
|
return data_append_data(d, &value_64, 8);
|
|
|
|
default:
|
|
die("Invalid literal size (%d)\n", bits);
|
|
}
|
|
}
|
|
|
|
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_cell(struct data d, cell_t word)
|
|
{
|
|
return data_append_integer(d, word, sizeof(word) * 8);
|
|
}
|
|
|
|
struct data data_append_addr(struct data d, uint64_t addr)
|
|
{
|
|
return data_append_integer(d, addr, sizeof(addr) * 8);
|
|
}
|
|
|
|
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;
|
|
}
|