blob: dd9c2574fdc95721d9f5a36a9a53eee403e390bc [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001// SPDX-License-Identifier: GPL-2.0+
Kumar Galad0586982008-02-14 20:44:42 -06002/*
3 * Copyright 2008 Freescale Semiconductor, Inc.
Wolfgang Denk855f18e2013-03-23 23:50:34 +00004 * Copyright 2013 Wolfgang Denk <wd@denx.de>
Kumar Galad0586982008-02-14 20:44:42 -06005 */
6
7/*
8 * This file provides a shell like 'expr' function to return.
9 */
10
11#include <common.h>
12#include <config.h>
13#include <command.h>
Simon Glassc7694dd2019-08-01 09:46:46 -060014#include <env.h>
Simon Glassf7ae49f2020-05-10 11:40:05 -060015#include <log.h>
Joe Hershberger2068cea2015-05-11 13:53:13 -050016#include <mapmem.h>
Kumar Galad0586982008-02-14 20:44:42 -060017
Frans Meulenbroeks47ab5ad2010-02-26 14:00:19 +010018static ulong get_arg(char *s, int w)
19{
Wolfgang Denk482126e2010-06-23 20:50:54 +020020 /*
Joe Hershberger2068cea2015-05-11 13:53:13 -050021 * If the parameter starts with a '*' then assume it is a pointer to
22 * the value we want.
Frans Meulenbroeks47ab5ad2010-02-26 14:00:19 +010023 */
Frans Meulenbroeks47ab5ad2010-02-26 14:00:19 +010024 if (s[0] == '*') {
Joe Hershberger2068cea2015-05-11 13:53:13 -050025 ulong *p;
26 ulong addr;
27 ulong val;
28
29 addr = simple_strtoul(&s[1], NULL, 16);
Frans Meulenbroeks47ab5ad2010-02-26 14:00:19 +010030 switch (w) {
Joe Hershberger2068cea2015-05-11 13:53:13 -050031 case 1:
32 p = map_sysmem(addr, sizeof(uchar));
33 val = (ulong)*(uchar *)p;
34 unmap_sysmem(p);
35 return val;
36 case 2:
37 p = map_sysmem(addr, sizeof(ushort));
38 val = (ulong)*(ushort *)p;
39 unmap_sysmem(p);
40 return val;
Frans Meulenbroeks47ab5ad2010-02-26 14:00:19 +010041 case 4:
Simon Glass25a43ac2020-11-01 14:15:37 -070042 p = map_sysmem(addr, sizeof(u32));
43 val = *(u32 *)p;
44 unmap_sysmem(p);
45 return val;
Joe Hershberger2068cea2015-05-11 13:53:13 -050046 default:
47 p = map_sysmem(addr, sizeof(ulong));
48 val = *p;
49 unmap_sysmem(p);
50 return val;
Frans Meulenbroeks47ab5ad2010-02-26 14:00:19 +010051 }
52 } else {
53 return simple_strtoul(s, NULL, 16);
54 }
55}
56
Wolfgang Denk855f18e2013-03-23 23:50:34 +000057#ifdef CONFIG_REGEX
58
59#include <slre.h>
60
61#define SLRE_BUFSZ 16384
62#define SLRE_PATSZ 4096
63
64/*
65 * memstr - Find the first substring in memory
66 * @s1: The string to be searched
67 * @s2: The string to search for
68 *
69 * Similar to and based on strstr(),
70 * but strings do not need to be NUL terminated.
71 */
72static char *memstr(const char *s1, int l1, const char *s2, int l2)
73{
74 if (!l2)
75 return (char *)s1;
76
77 while (l1 >= l2) {
78 l1--;
79 if (!memcmp(s1, s2, l2))
80 return (char *)s1;
81 s1++;
82 }
83 return NULL;
84}
85
86static char *substitute(char *string, /* string buffer */
87 int *slen, /* current string length */
88 int ssize, /* string bufer size */
89 const char *old,/* old (replaced) string */
90 int olen, /* length of old string */
91 const char *new,/* new (replacement) string */
92 int nlen) /* length of new string */
93{
94 char *p = memstr(string, *slen, old, olen);
95
96 if (p == NULL)
97 return NULL;
98
99 debug("## Match at pos %ld: match len %d, subst len %d\n",
100 (long)(p - string), olen, nlen);
101
102 /* make sure replacement matches */
103 if (*slen + nlen - olen > ssize) {
104 printf("## error: substitution buffer overflow\n");
105 return NULL;
106 }
107
108 /* move tail if needed */
109 if (olen != nlen) {
110 int tail, len;
111
112 len = (olen > nlen) ? olen : nlen;
113
114 tail = ssize - (p + len - string);
115
116 debug("## tail len %d\n", tail);
117
118 memmove(p + nlen, p + olen, tail);
119 }
120
121 /* insert substitue */
122 memcpy(p, new, nlen);
123
124 *slen += nlen - olen;
125
126 return p + nlen;
127}
128
129/*
130 * Perform regex operations on a environment variable
131 *
132 * Returns 0 if OK, 1 in case of errors.
133 */
134static int regex_sub(const char *name,
135 const char *r, const char *s, const char *t,
136 int global)
137{
138 struct slre slre;
139 char data[SLRE_BUFSZ];
140 char *datap = data;
141 const char *value;
142 int res, len, nlen, loop;
143
144 if (name == NULL)
145 return 1;
146
147 if (slre_compile(&slre, r) == 0) {
148 printf("Error compiling regex: %s\n", slre.err_str);
149 return 1;
150 }
151
152 if (t == NULL) {
Simon Glass00caae62017-08-03 12:22:12 -0600153 value = env_get(name);
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000154
155 if (value == NULL) {
156 printf("## Error: variable \"%s\" not defined\n", name);
157 return 1;
158 }
159 t = value;
160 }
161
162 debug("REGEX on %s=%s\n", name, t);
163 debug("REGEX=\"%s\", SUBST=\"%s\", GLOBAL=%d\n",
164 r, s ? s : "<NULL>", global);
165
166 len = strlen(t);
167 if (len + 1 > SLRE_BUFSZ) {
168 printf("## error: subst buffer overflow: have %d, need %d\n",
169 SLRE_BUFSZ, len + 1);
170 return 1;
171 }
172
173 strcpy(data, t);
174
175 if (s == NULL)
176 nlen = 0;
177 else
178 nlen = strlen(s);
179
180 for (loop = 0;; loop++) {
181 struct cap caps[slre.num_caps + 2];
182 char nbuf[SLRE_PATSZ];
183 const char *old;
184 char *np;
185 int i, olen;
186
187 (void) memset(caps, 0, sizeof(caps));
188
189 res = slre_match(&slre, datap, len, caps);
190
191 debug("Result: %d\n", res);
192
193 for (i = 0; i < slre.num_caps; i++) {
194 if (caps[i].len > 0) {
195 debug("Substring %d: [%.*s]\n", i,
196 caps[i].len, caps[i].ptr);
197 }
198 }
199
200 if (res == 0) {
201 if (loop == 0) {
202 printf("%s: No match\n", t);
203 return 1;
204 } else {
205 break;
206 }
207 }
208
209 debug("## MATCH ## %s\n", data);
210
211 if (s == NULL) {
212 printf("%s=%s\n", name, t);
213 return 1;
214 }
215
216 old = caps[0].ptr;
217 olen = caps[0].len;
218
219 if (nlen + 1 >= SLRE_PATSZ) {
220 printf("## error: pattern buffer overflow: have %d, need %d\n",
221 SLRE_BUFSZ, nlen + 1);
222 return 1;
223 }
224 strcpy(nbuf, s);
225
226 debug("## SUBST(1) ## %s\n", nbuf);
227
228 /*
229 * Handle back references
230 *
231 * Support for \0 ... \9, where \0 is the
232 * whole matched pattern (similar to &).
233 *
234 * Implementation is a bit simpleminded as
235 * backrefs are substituted sequentially, one
236 * by one. This will lead to somewhat
237 * unexpected results if the replacement
238 * strings contain any \N strings then then
239 * may get substitued, too. We accept this
240 * restriction for the sake of simplicity.
241 */
242 for (i = 0; i < 10; ++i) {
243 char backref[2] = {
244 '\\',
245 '0',
246 };
247
248 if (caps[i].len == 0)
249 break;
250
251 backref[1] += i;
252
253 debug("## BACKREF %d: replace \"%.*s\" by \"%.*s\" in \"%s\"\n",
254 i,
255 2, backref,
256 caps[i].len, caps[i].ptr,
257 nbuf);
258
259 for (np = nbuf;;) {
260 char *p = memstr(np, nlen, backref, 2);
261
262 if (p == NULL)
263 break;
264
265 np = substitute(np, &nlen,
266 SLRE_PATSZ,
267 backref, 2,
268 caps[i].ptr, caps[i].len);
269
270 if (np == NULL)
271 return 1;
272 }
273 }
274 debug("## SUBST(2) ## %s\n", nbuf);
275
276 datap = substitute(datap, &len, SLRE_BUFSZ,
277 old, olen,
278 nbuf, nlen);
279
280 if (datap == NULL)
281 return 1;
282
283 debug("## REMAINDER: %s\n", datap);
284
285 debug("## RESULT: %s\n", data);
286
287 if (!global)
288 break;
289 }
Simon Glass382bee52017-08-03 12:22:09 -0600290 debug("## FINAL (now env_set()) : %s\n", data);
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000291
292 printf("%s=%s\n", name, data);
293
Simon Glass382bee52017-08-03 12:22:09 -0600294 return env_set(name, data);
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000295}
296#endif
297
Simon Glass09140112020-05-10 11:40:03 -0600298static int do_setexpr(struct cmd_tbl *cmdtp, int flag, int argc,
299 char *const argv[])
Kumar Galad0586982008-02-14 20:44:42 -0600300{
301 ulong a, b;
Simon Glass41ef3722013-02-24 17:33:22 +0000302 ulong value;
Frans Meulenbroeks47ab5ad2010-02-26 14:00:19 +0100303 int w;
Kumar Galad0586982008-02-14 20:44:42 -0600304
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000305 /*
306 * We take 3, 5, or 6 arguments:
307 * 3 : setexpr name value
308 * 5 : setexpr name val1 op val2
309 * setexpr name [g]sub r s
310 * 6 : setexpr name [g]sub r s t
311 */
312
313 /* > 6 already tested by max command args */
314 if ((argc < 3) || (argc == 4))
Simon Glass4c12eeb2011-12-10 08:44:01 +0000315 return CMD_RET_USAGE;
Kumar Galad0586982008-02-14 20:44:42 -0600316
Frans Meulenbroeks47ab5ad2010-02-26 14:00:19 +0100317 w = cmd_get_data_size(argv[0], 4);
318
319 a = get_arg(argv[2], w);
Joe Hershberger4823b452012-11-01 16:21:14 +0000320
Wolfgang Denk103c94b2013-03-23 23:50:33 +0000321 /* plain assignment: "setexpr name value" */
Joe Hershberger4823b452012-11-01 16:21:14 +0000322 if (argc == 3) {
Simon Glass018f5302017-08-03 12:22:10 -0600323 env_set_hex(argv[1], a);
Joe Hershberger4823b452012-11-01 16:21:14 +0000324 return 0;
325 }
326
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000327 /* 5 or 6 args (6 args only with [g]sub) */
328#ifdef CONFIG_REGEX
329 /*
330 * rexep handling: "setexpr name [g]sub r s [t]"
331 * with 5 args, "t" will be NULL
332 */
333 if (strcmp(argv[2], "gsub") == 0)
334 return regex_sub(argv[1], argv[3], argv[4], argv[5], 1);
335
336 if (strcmp(argv[2], "sub") == 0)
337 return regex_sub(argv[1], argv[3], argv[4], argv[5], 0);
338#endif
339
Wolfgang Denk103c94b2013-03-23 23:50:33 +0000340 /* standard operators: "setexpr name val1 op val2" */
341 if (argc != 5)
342 return CMD_RET_USAGE;
343
344 if (strlen(argv[3]) != 1)
345 return CMD_RET_USAGE;
346
Frans Meulenbroeks47ab5ad2010-02-26 14:00:19 +0100347 b = get_arg(argv[4], w);
Kumar Galad0586982008-02-14 20:44:42 -0600348
349 switch (argv[3][0]) {
Simon Glass41ef3722013-02-24 17:33:22 +0000350 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 case '/':
369 value = a / b;
370 break;
371 case '%':
372 value = a % b;
373 break;
Kumar Galad0586982008-02-14 20:44:42 -0600374 default:
375 printf("invalid op\n");
376 return 1;
377 }
378
Simon Glass018f5302017-08-03 12:22:10 -0600379 env_set_hex(argv[1], value);
Kumar Galad0586982008-02-14 20:44:42 -0600380
381 return 0;
382}
383
384U_BOOT_CMD(
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000385 setexpr, 6, 0, do_setexpr,
Peter Tyser2fb26042009-01-27 18:03:12 -0600386 "set environment variable as the result of eval expression",
Joe Hershberger4823b452012-11-01 16:21:14 +0000387 "[.b, .w, .l] name [*]value1 <op> [*]value2\n"
Kumar Galad0586982008-02-14 20:44:42 -0600388 " - set environment variable 'name' to the result of the evaluated\n"
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000389 " expression specified by <op>. <op> can be &, |, ^, +, -, *, /, %\n"
Joe Hershberger4823b452012-11-01 16:21:14 +0000390 " size argument is only meaningful if value1 and/or value2 are\n"
391 " memory addresses (*)\n"
Wolfgang Denk103c94b2013-03-23 23:50:33 +0000392 "setexpr[.b, .w, .l] name [*]value\n"
393 " - load a value into a variable"
Wolfgang Denk855f18e2013-03-23 23:50:34 +0000394#ifdef CONFIG_REGEX
395 "\n"
396 "setexpr name gsub r s [t]\n"
397 " - For each substring matching the regular expression <r> in the\n"
398 " string <t>, substitute the string <s>. The result is\n"
399 " assigned to <name>. If <t> is not supplied, use the old\n"
400 " value of <name>\n"
401 "setexpr name sub r s [t]\n"
402 " - Just like gsub(), but replace only the first matching substring"
403#endif
Kumar Galad0586982008-02-14 20:44:42 -0600404);