]> git.ipfire.org Git - people/ms/u-boot.git/blob - common/cmd_setexpr.c
board: ti: beagle_x15: added USB initializtion code
[people/ms/u-boot.git] / common / cmd_setexpr.c
1 /*
2 * Copyright 2008 Freescale Semiconductor, Inc.
3 * Copyright 2013 Wolfgang Denk <wd@denx.de>
4 *
5 * SPDX-License-Identifier: GPL-2.0+
6 */
7
8 /*
9 * This file provides a shell like 'expr' function to return.
10 */
11
12 #include <common.h>
13 #include <config.h>
14 #include <command.h>
15 #include <mapmem.h>
16
17 static ulong get_arg(char *s, int w)
18 {
19 /*
20 * If the parameter starts with a '*' then assume it is a pointer to
21 * the value we want.
22 */
23 if (s[0] == '*') {
24 ulong *p;
25 ulong addr;
26 ulong val;
27
28 addr = simple_strtoul(&s[1], NULL, 16);
29 switch (w) {
30 case 1:
31 p = map_sysmem(addr, sizeof(uchar));
32 val = (ulong)*(uchar *)p;
33 unmap_sysmem(p);
34 return val;
35 case 2:
36 p = map_sysmem(addr, sizeof(ushort));
37 val = (ulong)*(ushort *)p;
38 unmap_sysmem(p);
39 return val;
40 case 4:
41 default:
42 p = map_sysmem(addr, sizeof(ulong));
43 val = *p;
44 unmap_sysmem(p);
45 return val;
46 }
47 } else {
48 return simple_strtoul(s, NULL, 16);
49 }
50 }
51
52 #ifdef CONFIG_REGEX
53
54 #include <slre.h>
55
56 #define SLRE_BUFSZ 16384
57 #define SLRE_PATSZ 4096
58
59 /*
60 * memstr - Find the first substring in memory
61 * @s1: The string to be searched
62 * @s2: The string to search for
63 *
64 * Similar to and based on strstr(),
65 * but strings do not need to be NUL terminated.
66 */
67 static char *memstr(const char *s1, int l1, const char *s2, int l2)
68 {
69 if (!l2)
70 return (char *)s1;
71
72 while (l1 >= l2) {
73 l1--;
74 if (!memcmp(s1, s2, l2))
75 return (char *)s1;
76 s1++;
77 }
78 return NULL;
79 }
80
81 static char *substitute(char *string, /* string buffer */
82 int *slen, /* current string length */
83 int ssize, /* string bufer size */
84 const char *old,/* old (replaced) string */
85 int olen, /* length of old string */
86 const char *new,/* new (replacement) string */
87 int nlen) /* length of new string */
88 {
89 char *p = memstr(string, *slen, old, olen);
90
91 if (p == NULL)
92 return NULL;
93
94 debug("## Match at pos %ld: match len %d, subst len %d\n",
95 (long)(p - string), olen, nlen);
96
97 /* make sure replacement matches */
98 if (*slen + nlen - olen > ssize) {
99 printf("## error: substitution buffer overflow\n");
100 return NULL;
101 }
102
103 /* move tail if needed */
104 if (olen != nlen) {
105 int tail, len;
106
107 len = (olen > nlen) ? olen : nlen;
108
109 tail = ssize - (p + len - string);
110
111 debug("## tail len %d\n", tail);
112
113 memmove(p + nlen, p + olen, tail);
114 }
115
116 /* insert substitue */
117 memcpy(p, new, nlen);
118
119 *slen += nlen - olen;
120
121 return p + nlen;
122 }
123
124 /*
125 * Perform regex operations on a environment variable
126 *
127 * Returns 0 if OK, 1 in case of errors.
128 */
129 static int regex_sub(const char *name,
130 const char *r, const char *s, const char *t,
131 int global)
132 {
133 struct slre slre;
134 char data[SLRE_BUFSZ];
135 char *datap = data;
136 const char *value;
137 int res, len, nlen, loop;
138
139 if (name == NULL)
140 return 1;
141
142 if (slre_compile(&slre, r) == 0) {
143 printf("Error compiling regex: %s\n", slre.err_str);
144 return 1;
145 }
146
147 if (t == NULL) {
148 value = getenv(name);
149
150 if (value == NULL) {
151 printf("## Error: variable \"%s\" not defined\n", name);
152 return 1;
153 }
154 t = value;
155 }
156
157 debug("REGEX on %s=%s\n", name, t);
158 debug("REGEX=\"%s\", SUBST=\"%s\", GLOBAL=%d\n",
159 r, s ? s : "<NULL>", global);
160
161 len = strlen(t);
162 if (len + 1 > SLRE_BUFSZ) {
163 printf("## error: subst buffer overflow: have %d, need %d\n",
164 SLRE_BUFSZ, len + 1);
165 return 1;
166 }
167
168 strcpy(data, t);
169
170 if (s == NULL)
171 nlen = 0;
172 else
173 nlen = strlen(s);
174
175 for (loop = 0;; loop++) {
176 struct cap caps[slre.num_caps + 2];
177 char nbuf[SLRE_PATSZ];
178 const char *old;
179 char *np;
180 int i, olen;
181
182 (void) memset(caps, 0, sizeof(caps));
183
184 res = slre_match(&slre, datap, len, caps);
185
186 debug("Result: %d\n", res);
187
188 for (i = 0; i < slre.num_caps; i++) {
189 if (caps[i].len > 0) {
190 debug("Substring %d: [%.*s]\n", i,
191 caps[i].len, caps[i].ptr);
192 }
193 }
194
195 if (res == 0) {
196 if (loop == 0) {
197 printf("%s: No match\n", t);
198 return 1;
199 } else {
200 break;
201 }
202 }
203
204 debug("## MATCH ## %s\n", data);
205
206 if (s == NULL) {
207 printf("%s=%s\n", name, t);
208 return 1;
209 }
210
211 old = caps[0].ptr;
212 olen = caps[0].len;
213
214 if (nlen + 1 >= SLRE_PATSZ) {
215 printf("## error: pattern buffer overflow: have %d, need %d\n",
216 SLRE_BUFSZ, nlen + 1);
217 return 1;
218 }
219 strcpy(nbuf, s);
220
221 debug("## SUBST(1) ## %s\n", nbuf);
222
223 /*
224 * Handle back references
225 *
226 * Support for \0 ... \9, where \0 is the
227 * whole matched pattern (similar to &).
228 *
229 * Implementation is a bit simpleminded as
230 * backrefs are substituted sequentially, one
231 * by one. This will lead to somewhat
232 * unexpected results if the replacement
233 * strings contain any \N strings then then
234 * may get substitued, too. We accept this
235 * restriction for the sake of simplicity.
236 */
237 for (i = 0; i < 10; ++i) {
238 char backref[2] = {
239 '\\',
240 '0',
241 };
242
243 if (caps[i].len == 0)
244 break;
245
246 backref[1] += i;
247
248 debug("## BACKREF %d: replace \"%.*s\" by \"%.*s\" in \"%s\"\n",
249 i,
250 2, backref,
251 caps[i].len, caps[i].ptr,
252 nbuf);
253
254 for (np = nbuf;;) {
255 char *p = memstr(np, nlen, backref, 2);
256
257 if (p == NULL)
258 break;
259
260 np = substitute(np, &nlen,
261 SLRE_PATSZ,
262 backref, 2,
263 caps[i].ptr, caps[i].len);
264
265 if (np == NULL)
266 return 1;
267 }
268 }
269 debug("## SUBST(2) ## %s\n", nbuf);
270
271 datap = substitute(datap, &len, SLRE_BUFSZ,
272 old, olen,
273 nbuf, nlen);
274
275 if (datap == NULL)
276 return 1;
277
278 debug("## REMAINDER: %s\n", datap);
279
280 debug("## RESULT: %s\n", data);
281
282 if (!global)
283 break;
284 }
285 debug("## FINAL (now setenv()) : %s\n", data);
286
287 printf("%s=%s\n", name, data);
288
289 return setenv(name, data);
290 }
291 #endif
292
293 static int do_setexpr(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
294 {
295 ulong a, b;
296 ulong value;
297 int w;
298
299 /*
300 * We take 3, 5, or 6 arguments:
301 * 3 : setexpr name value
302 * 5 : setexpr name val1 op val2
303 * setexpr name [g]sub r s
304 * 6 : setexpr name [g]sub r s t
305 */
306
307 /* > 6 already tested by max command args */
308 if ((argc < 3) || (argc == 4))
309 return CMD_RET_USAGE;
310
311 w = cmd_get_data_size(argv[0], 4);
312
313 a = get_arg(argv[2], w);
314
315 /* plain assignment: "setexpr name value" */
316 if (argc == 3) {
317 setenv_hex(argv[1], a);
318 return 0;
319 }
320
321 /* 5 or 6 args (6 args only with [g]sub) */
322 #ifdef CONFIG_REGEX
323 /*
324 * rexep handling: "setexpr name [g]sub r s [t]"
325 * with 5 args, "t" will be NULL
326 */
327 if (strcmp(argv[2], "gsub") == 0)
328 return regex_sub(argv[1], argv[3], argv[4], argv[5], 1);
329
330 if (strcmp(argv[2], "sub") == 0)
331 return regex_sub(argv[1], argv[3], argv[4], argv[5], 0);
332 #endif
333
334 /* standard operators: "setexpr name val1 op val2" */
335 if (argc != 5)
336 return CMD_RET_USAGE;
337
338 if (strlen(argv[3]) != 1)
339 return CMD_RET_USAGE;
340
341 b = get_arg(argv[4], w);
342
343 switch (argv[3][0]) {
344 case '|':
345 value = a | b;
346 break;
347 case '&':
348 value = a & b;
349 break;
350 case '+':
351 value = a + b;
352 break;
353 case '^':
354 value = a ^ b;
355 break;
356 case '-':
357 value = a - b;
358 break;
359 case '*':
360 value = a * b;
361 break;
362 case '/':
363 value = a / b;
364 break;
365 case '%':
366 value = a % b;
367 break;
368 default:
369 printf("invalid op\n");
370 return 1;
371 }
372
373 setenv_hex(argv[1], value);
374
375 return 0;
376 }
377
378 U_BOOT_CMD(
379 setexpr, 6, 0, do_setexpr,
380 "set environment variable as the result of eval expression",
381 "[.b, .w, .l] name [*]value1 <op> [*]value2\n"
382 " - set environment variable 'name' to the result of the evaluated\n"
383 " expression specified by <op>. <op> can be &, |, ^, +, -, *, /, %\n"
384 " size argument is only meaningful if value1 and/or value2 are\n"
385 " memory addresses (*)\n"
386 "setexpr[.b, .w, .l] name [*]value\n"
387 " - load a value into a variable"
388 #ifdef CONFIG_REGEX
389 "\n"
390 "setexpr name gsub r s [t]\n"
391 " - For each substring matching the regular expression <r> in the\n"
392 " string <t>, substitute the string <s>. The result is\n"
393 " assigned to <name>. If <t> is not supplied, use the old\n"
394 " value of <name>\n"
395 "setexpr name sub r s [t]\n"
396 " - Just like gsub(), but replace only the first matching substring"
397 #endif
398 );