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