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