~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/scripts/dtc/data.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * (C) Copyright David Gibson <dwg@au1.ibm.com>, 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 
 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 
 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 
 54         nd.val = xrealloc(d.val, newsize);
 55 
 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';
 78         strncpy(x, s + *i, 3);
 79 
 80         val = strtol(x, &endx, 8);
 81 
 82         assert(endx > x);
 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';
 95         strncpy(x, s + *i, 2);
 96 
 97         val = strtol(x, &endx, 16);
 98         if (!(endx  > x))
 99                 die("\\x used with no following hex digits\n");
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 '':
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 
170 struct data data_copy_file(FILE *f, size_t maxlen)
171 {
172         struct data d = empty_data;
173 
174         while (!feof(f) && (d.len < maxlen)) {
175                 size_t chunksize, ret;
176 
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         }
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 
220 static struct data data_append_markers(struct data d, struct marker *m)
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 {
250         cell_t beword = cpu_to_fdt32(word);
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 
259         bere.address = cpu_to_fdt64(re->address);
260         bere.size = cpu_to_fdt64(re->size);
261 
262         return data_append_data(d, &bere, sizeof(bere));
263 }
264 
265 struct data data_append_addr(struct data d, uint64_t addr)
266 {
267         uint64_t beaddr = cpu_to_fdt64(addr);
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 }
322 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp