← Back to branch summary

~ubuntu-branches/ubuntu/warty/bash/warty

« back to all changes in this revision

Viewing changes to bracecomp.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2002-04-08 20:51:41 UTC
  • Revision ID: james.westby@ubuntu.com-20020408205141-qovkhu3a90201hf2
Tags: upstream-2.05a
Import upstream version 2.05a

Show diffs side-by-side

added added

removed removed

Lines of Context:
bracecomp.c
 
1
/* bracecomp.c -- Complete a filename with the possible completions enclosed
 
2
   in csh-style braces such that the list of completions is available to the
 
3
   shell. */
 
4
 
 
5
/* Original version by tromey@cns.caltech.edu,  Fri Feb  7 1992. */
 
6
 
 
7
/* Copyright (C) 1993 Free Software Foundation, Inc.
 
8
 
 
9
   This file is part of GNU Bash, the Bourne Again SHell.
 
10
 
 
11
   Bash is free software; you can redistribute it and/or modify it under
 
12
   the terms of the GNU General Public License as published by the Free
 
13
   Software Foundation; either version 2, or (at your option) any later
 
14
   version.
 
15
 
 
16
   Bash is distributed in the hope that it will be useful, but WITHOUT ANY
 
17
   WARRANTY; without even the implied warranty of MERCHANTABILITY or
 
18
   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 
19
   for more details.
 
20
 
 
21
   You should have received a copy of the GNU General Public License along
 
22
   with Bash; see the file COPYING.  If not, write to the Free Software
 
23
   Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
 
24
 
 
25
#include "config.h"
 
26
#if defined (BRACE_EXPANSION) && defined (READLINE)
 
27
 
 
28
#include <stdio.h>
 
29
 
 
30
#if defined (HAVE_UNISTD_H)
 
31
#  ifdef _MINIX
 
32
#    include <sys/types.h>
 
33
#  endif
 
34
#  include <unistd.h>
 
35
#endif
 
36
 
 
37
#include "bashansi.h"
 
38
 
 
39
#include "shell.h"
 
40
#include <readline/readline.h>
 
41
 
 
42
/* Find greatest common prefix of two strings. */
 
43
static int
 
44
string_gcd (s1, s2)
 
45
     char *s1, *s2;
 
46
{
 
47
  register int i;
 
48
 
 
49
  if (s1 == NULL || s2 == NULL)
 
50
    return (0);
 
51
 
 
52
  for (i = 0; *s1 && *s2; ++s1, ++s2, ++i)
 
53
    {
 
54
      if (*s1 != *s2)
 
55
        break;
 
56
    }
 
57
 
 
58
  return (i);
 
59
}
 
60
 
 
61
static char *
 
62
really_munge_braces (array, real_start, real_end, gcd_zero)
 
63
     char **array;
 
64
     int real_start, real_end, gcd_zero;
 
65
{
 
66
  int start, end, gcd;
 
67
  char *result, *subterm, *x;
 
68
  int result_size, flag, tlen;
 
69
 
 
70
  flag = 0;
 
71
 
 
72
  if (real_start == real_end)
 
73
    {
 
74
      x = array[real_start] ? sh_backslash_quote (array[real_start] + gcd_zero)
 
75
                            : sh_backslash_quote (array[0]);
 
76
      return x;
 
77
    }
 
78
 
 
79
  result = (char *)xmalloc (result_size = 16);
 
80
  *result = '\0';
 
81
 
 
82
  for (start = real_start; start < real_end; start = end + 1)
 
83
    {
 
84
      gcd = strlen (array[start]);
 
85
      for (end = start + 1; end < real_end; end++)
 
86
        {
 
87
          int temp;
 
88
 
 
89
          temp = string_gcd (array[start], array[end]);
 
90
 
 
91
          if (temp <= gcd_zero)
 
92
            break;
 
93
 
 
94
          gcd = temp;
 
95
        }
 
96
      end--;
 
97
 
 
98
      if (gcd_zero == 0 && start == real_start && end != (real_end - 1))
 
99
        {
 
100
          /* In this case, add in a leading '{', because we are at
 
101
             top level, and there isn't a consistent prefix. */
 
102
          result_size += 1;
 
103
          result = (char *)xrealloc (result, result_size);
 
104
          result[0] = '{'; result[1] = '\0';
 
105
          flag++;
 
106
        }
 
107
 
 
108
      /* Make sure we backslash quote every substring we insert into the
 
109
         resultant brace expression.  This is so the default filename
 
110
         quoting function won't inappropriately quote the braces. */
 
111
      if (start == end)
 
112
        {
 
113
          x = savestring (array[start] + gcd_zero);
 
114
          subterm = sh_backslash_quote (x);
 
115
          free (x);
 
116
        }
 
117
      else
 
118
        {
 
119
          /* If there is more than one element in the subarray,
 
120
             insert the (quoted) prefix and an opening brace. */
 
121
          tlen = gcd - gcd_zero;
 
122
          x = (char *)xmalloc (tlen + 1);
 
123
          strncpy (x, array[start] + gcd_zero, tlen);
 
124
          x[tlen] = '\0';
 
125
          subterm = sh_backslash_quote (x);
 
126
          free (x);
 
127
          result_size += strlen (subterm) + 1;
 
128
          result = (char *)xrealloc (result, result_size);
 
129
          strcat (result, subterm);
 
130
          free (subterm);
 
131
          strcat (result, "{");
 
132
          subterm = really_munge_braces (array, start, end + 1, gcd);
 
133
          subterm[strlen (subterm) - 1] = '}';
 
134
        }
 
135
 
 
136
      result_size += strlen (subterm) + 1;
 
137
      result = (char *)xrealloc (result, result_size);
 
138
      strcat (result, subterm);
 
139
      strcat (result, ",");
 
140
      free (subterm);
 
141
    }
 
142
 
 
143
  if (gcd_zero == 0)
 
144
    result[strlen (result) - 1] = flag ? '}' : '\0';
 
145
  return (result);
 
146
}
 
147
 
 
148
static int
 
149
hack_braces_completion (names)
 
150
     char **names;
 
151
{
 
152
  register int i;
 
153
  char *temp;
 
154
 
 
155
  temp = really_munge_braces (names, 1, array_len (names), 0);
 
156
 
 
157
  for (i = 0; names[i]; ++i)
 
158
    {
 
159
      free (names[i]);
 
160
      names[i] = NULL;
 
161
    }
 
162
  names[0] = temp;
 
163
  return 0;
 
164
}
 
165
 
 
166
/* We handle quoting ourselves within hack_braces_completion, so we turn off
 
167
   rl_filename_quoting_desired and rl_filename_quoting_function. */
 
168
int
 
169
bash_brace_completion (count, ignore)
 
170
     int count, ignore;
 
171
{
 
172
  rl_compignore_func_t *orig_ignore_func;
 
173
  rl_compentry_func_t *orig_entry_func;
 
174
  rl_quote_func_t *orig_quoting_func;
 
175
  rl_completion_func_t *orig_attempt_func;
 
176
  int orig_quoting_desired, r;
 
177
 
 
178
  orig_ignore_func = rl_ignore_some_completions_function;
 
179
  orig_attempt_func = rl_attempted_completion_function;
 
180
  orig_entry_func = rl_completion_entry_function;
 
181
  orig_quoting_func = rl_filename_quoting_function;
 
182
  orig_quoting_desired = rl_filename_quoting_desired;
 
183
 
 
184
  rl_completion_entry_function = rl_filename_completion_function;
 
185
  rl_attempted_completion_function = (rl_completion_func_t *)NULL;
 
186
  rl_ignore_some_completions_function = hack_braces_completion;
 
187
  rl_filename_quoting_function = (rl_quote_func_t *)NULL;
 
188
  rl_filename_quoting_desired = 0;
 
189
 
 
190
  r = rl_complete_internal (TAB);
 
191
 
 
192
  rl_ignore_some_completions_function = orig_ignore_func;
 
193
  rl_attempted_completion_function = orig_attempt_func;
 
194
  rl_completion_entry_function = orig_entry_func;
 
195
  rl_filename_quoting_function = orig_quoting_func;
 
196
  rl_filename_quoting_desired = orig_quoting_desired;
 
197
 
 
198
  return r;
 
199
}
 
200
#endif /* BRACE_EXPANSION && READLINE */