hush: initial stab at brace expansion support

Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>

1 files changed, 133 insertions, 4 deletions

diff --git a/shell/hush.c b/shell/hush.c
index 235cee9ee..171b73940 100644
--- a/shell/hush.c
+++ b/shell/hush.c
@@ -2003,6 +2003,130 @@ static int o_get_last_ptr(o_string *o, int n)
 	return ((int)(ptrdiff_t)list[n-1]) + string_start;
 }
 
+#undef HUSH_BRACE_EXP
+/* There in a GNU extension, GLOB_BRACE, but it is not usable:
+ * first, it processes even {a} (no commas), second,
+ * I didn't manage to make it return strings when they don't match
+ # existing files. Need to re-implement it.
+ *
+ * This code needs corresponding quoting on variable expansion side.
+ * Currently, "a='{q,w}'; echo $a" erroneously expands braces in $a
+ */
+#ifdef HUSH_BRACE_EXP
+/* Return pointer to next closing brace or to comma */
+static const char *next_brace_sub(const char *cp)
+{
+	unsigned depth = 0;
+	cp++;
+	while (*cp != '\0') {
+		if (*cp == '\\') {
+			if (*++cp == '\0')
+				break;
+			cp++;
+			continue;
+    		}
+		 /*{*/ if ((*cp == '}' && depth-- == 0) || (*cp == ',' && depth == 0))
+			break;
+		if (*cp++ == '{') /*}*/
+			depth++;
+	}
+
+	return *cp != '\0' ? cp : NULL;
+}
+static int glob_brace(const char *pattern, int flags, glob_t *pglob)
+{
+	const char *begin;
+	char *alt_start;
+	const char *p;
+	const char *next;
+	const char *rest;
+	size_t rest_len;
+	char *onealt;
+
+	debug_printf_glob("glob_brace('%s')\n", pattern);
+
+	begin = pattern;
+	while (1) {
+		if (*begin == '\0')
+			goto do_glob;
+		if (*begin == '{') /*}*/ {
+			/* Find the first sub-pattern and at the same time
+			 * find the rest after the closing brace */
+			next = next_brace_sub(begin);
+			if (next == NULL) {
+				/* An illegal expression */
+				goto do_glob;
+			}
+			/*{*/ if (*next == '}') {
+				/* "{abc}" with no commas - illegal
+				 * brace expr, disregard and skip it */
+				begin = next + 1;
+				continue;
+			}
+			break;
+		}
+		if (*begin == '\\' && begin[1] != '\0')
+			begin++;
+		begin++;
+	}
+	debug_printf_glob("begin:%s\n", begin);
+	debug_printf_glob("next:%s\n", next);
+
+	/* Now find the end of the whole brace expression */
+	rest = next;
+	/*{*/ while (*rest != '}') {
+		rest = next_brace_sub(rest);
+		if (rest == NULL) {
+			/* An illegal expression */
+			goto do_glob;
+		}
+		debug_printf_glob("rest:%s\n", rest);
+	}
+	rest_len = strlen(++rest) + 1;
+
+	/* We are sure the brace expression is well-formed */
+
+	/* Allocate working buffer large enough for our work */
+	onealt = alloca(strlen(pattern));
+	/* We know the prefix for all sub-patterns */
+	alt_start = mempcpy(onealt, pattern, begin - pattern);
+
+	/* We have a brace expression.  BEGIN points to the opening {,
+	 * NEXT points past the terminator of the first element, and REST
+	 * points past the final }.  We will accumulate result names from
+	 * recursive runs for each brace alternative in the buffer using
+	 * GLOB_APPEND.  */
+
+	p = begin + 1;
+	while (1) {
+		int result;
+
+		/* Construct the new glob expression */
+		memcpy(mempcpy(alt_start, p, next - p), rest, rest_len);
+
+		result = glob_brace(onealt, flags, pglob);
+		/* If we got an error, return it */
+		if (result && result != GLOB_NOMATCH)
+			return result;
+
+		flags |= GLOB_APPEND;
+
+		/*{*/ if (*next == '}') {
+			/* We saw the last entry */
+			break;
+		}
+		p = next + 1;
+		next = next_brace_sub(next);
+	}
+
+	/* We found some entries */
+	return 0;
+
+ do_glob:
+	return glob(pattern, flags, NULL, pglob);
+}
+#endif
+
 /* o_glob performs globbing on last list[], saving each result
  * as a new list[]. */
 static int o_glob(o_string *o, int n)
@@ -2024,17 +2148,22 @@ static int o_glob(o_string *o, int n)
 	}
 
 	memset(&globdata, 0, sizeof(globdata));
-//TODO: can use GLOB_BRACE | GLOB_TILDE here:
+#ifdef HUSH_BRACE_EXP
+	gr = glob_brace(pattern, GLOB_NOCHECK, &globdata);
+	debug_printf_glob("glob_brace('%s'):%d\n", pattern, gr);
+#else
 	gr = glob(pattern, 0, NULL, &globdata);
 	debug_printf_glob("glob('%s'):%d\n", pattern, gr);
+#endif
 	if (gr == GLOB_NOSPACE)
-		bb_error_msg_and_die("out of memory during glob");
+		bb_error_msg_and_die(bb_msg_memory_exhausted);
 	if (gr == GLOB_NOMATCH) {
 		globfree(&globdata);
 		goto literal;
 	}
-	if (gr != 0) { /* GLOB_ABORTED ? */
-		/* TODO: testcase for bad glob pattern behavior */
+	if (gr != 0) {
+		/* GLOB_ABORTED? Only happens with GLOB_ERR flag,
+		 * but we didn't specify it. Paranoia again. */
 		bb_error_msg("glob(3) error %d on '%s'", gr, pattern);
 	}
 	if (globdata.gl_pathv && globdata.gl_pathv[0]) {