Adding upstream version 5.0.upstream/5.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 221 insertions, 0 deletions

diff --git a/bracecomp.c b/bracecomp.c
new file mode 100644
index 0000000..4fbca85
--- /dev/null
+++ b/bracecomp.c
@@ -0,0 +1,221 @@
+/* bracecomp.c -- Complete a filename with the possible completions enclosed
+   in csh-style braces such that the list of completions is available to the
+   shell. */
+
+/* Original version by tromey@cns.caltech.edu,  Fri Feb  7 1992. */
+
+/* Copyright (C) 1993-2009 Free Software Foundation, Inc.
+
+   This file is part of GNU Bash, the Bourne Again SHell.
+
+   Bash is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   Bash is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "config.h"
+
+#if defined (BRACE_EXPANSION) && defined (READLINE)
+
+#include <stdio.h>
+
+#if defined (HAVE_UNISTD_H)
+#  ifdef _MINIX
+#    include <sys/types.h>
+#  endif
+#  include <unistd.h>
+#endif
+
+#include "bashansi.h"
+#include "shmbutil.h"
+
+#include "shell.h"
+#include <readline/readline.h>
+
+static int _strcompare __P((char **, char **));
+
+/* Find greatest common prefix of two strings. */
+static int
+string_gcd (s1, s2)
+     char *s1, *s2;
+{
+  register int i;
+
+  if (s1 == NULL || s2 == NULL)
+    return (0);
+
+  for (i = 0; *s1 && *s2; ++s1, ++s2, ++i)
+    {
+      if (*s1 != *s2)
+	break;
+    }
+
+  return (i);
+}
+
+static char *
+really_munge_braces (array, real_start, real_end, gcd_zero)
+     char **array;
+     int real_start, real_end, gcd_zero;
+{
+  int start, end, gcd;
+  char *result, *subterm, *x;
+  int result_size, flag, tlen;
+
+  flag = 0;
+
+  if (real_start == real_end)
+    {
+      x = array[real_start] ? sh_backslash_quote (array[real_start] + gcd_zero, 0, 0)
+ 			    : sh_backslash_quote (array[0], 0, 0);
+      return x;
+    }
+
+  result = (char *)xmalloc (result_size = 16);
+  *result = '\0';
+
+  for (start = real_start; start < real_end; start = end + 1)
+    {
+      gcd = strlen (array[start]);
+      for (end = start + 1; end < real_end; end++)
+	{
+	  int temp;
+
+	  temp = string_gcd (array[start], array[end]);
+
+	  if (temp <= gcd_zero)
+	    break;
+
+	  gcd = temp;
+	}
+      end--;
+
+      if (gcd_zero == 0 && start == real_start && end != (real_end - 1))
+	{
+	  /* In this case, add in a leading '{', because we are at
+	     top level, and there isn't a consistent prefix. */
+	  result_size += 1;
+	  result = (char *)xrealloc (result, result_size);
+	  result[0] = '{'; result[1] = '\0';
+	  flag++;
+	}
+
+      /* Make sure we backslash quote every substring we insert into the
+	 resultant brace expression.  This is so the default filename
+	 quoting function won't inappropriately quote the braces. */
+      if (start == end)
+	{
+	  x = savestring (array[start] + gcd_zero);
+	  subterm = sh_backslash_quote (x, 0, 0);
+	  free (x);
+	}
+      else
+	{
+	  /* If there is more than one element in the subarray,
+	     insert the (quoted) prefix and an opening brace. */
+	  tlen = gcd - gcd_zero;
+	  x = (char *)xmalloc (tlen + 1);
+	  strncpy (x, array[start] + gcd_zero, tlen);
+	  x[tlen] = '\0';
+	  subterm = sh_backslash_quote (x, 0, 0);
+	  free (x);
+	  result_size += strlen (subterm) + 1;
+	  result = (char *)xrealloc (result, result_size);
+	  strcat (result, subterm);
+	  free (subterm);
+	  strcat (result, "{");
+	  subterm = really_munge_braces (array, start, end + 1, gcd);
+	  subterm[strlen (subterm) - 1] = '}';
+	}
+
+      result_size += strlen (subterm) + 1;
+      result = (char *)xrealloc (result, result_size);
+      strcat (result, subterm);
+      strcat (result, ",");
+      free (subterm);
+    }
+
+  if (gcd_zero == 0)
+    result[strlen (result) - 1] = flag ? '}' : '\0';
+  return (result);
+}
+
+static int
+_strcompare (s1, s2)
+     char **s1, **s2;
+{
+  int result;
+
+  result = **s1 - **s2;
+  if (result == 0)
+    result = strcmp (*s1, *s2);
+
+  return result;
+}
+
+static int
+hack_braces_completion (names)
+     char **names;
+{
+  register int i;
+  char *temp;
+
+  i = strvec_len (names);
+  if (MB_CUR_MAX > 1 && i > 2)
+    qsort (names+1, i-1, sizeof (char *), (QSFUNC *)_strcompare);
+      
+  temp = really_munge_braces (names, 1, i, 0);
+
+  for (i = 0; names[i]; ++i)
+    {
+      free (names[i]);
+      names[i] = NULL;
+    }
+  names[0] = temp;
+  return 0;
+}
+
+/* We handle quoting ourselves within hack_braces_completion, so we turn off
+   rl_filename_quoting_desired and rl_filename_quoting_function. */
+int
+bash_brace_completion (count, ignore)
+     int count, ignore;
+{
+  rl_compignore_func_t *orig_ignore_func;
+  rl_compentry_func_t *orig_entry_func;
+  rl_quote_func_t *orig_quoting_func;
+  rl_completion_func_t *orig_attempt_func;
+  int orig_quoting_desired, r;
+
+  orig_ignore_func = rl_ignore_some_completions_function;
+  orig_attempt_func = rl_attempted_completion_function;
+  orig_entry_func = rl_completion_entry_function;
+  orig_quoting_func = rl_filename_quoting_function;
+  orig_quoting_desired = rl_filename_quoting_desired;
+
+  rl_completion_entry_function = rl_filename_completion_function;
+  rl_attempted_completion_function = (rl_completion_func_t *)NULL;
+  rl_ignore_some_completions_function = hack_braces_completion;
+  rl_filename_quoting_function = (rl_quote_func_t *)NULL;
+  rl_filename_quoting_desired = 0;
+
+  r = rl_complete_internal (TAB);
+
+  rl_ignore_some_completions_function = orig_ignore_func;
+  rl_attempted_completion_function = orig_attempt_func;
+  rl_completion_entry_function = orig_entry_func;
+  rl_filename_quoting_function = orig_quoting_func;
+  rl_filename_quoting_desired = orig_quoting_desired;
+
+  return r;
+}
+#endif /* BRACE_EXPANSION && READLINE */