lib/editline/complete.c

   1 /*  $Revision$
   2 **
   3 **  History and file completion functions for editline library.
   4 */
   5 #include "editline.h"
   6
   7
   8 #if     defined(NEED_STRDUP)
   9 /*
  10 **  Return an allocated copy of a string.
  11 */
  12 char *
  13 strdup(p)
  14     char        *p;
  15 {
  16     char        *new;
  17
  18     if ((new = NEW(char, strlen(p) + 1)) != NULL)
  19         (void)strcpy(new, p);
  20     return new;
  21 }
  22 #endif  /* defined(NEED_STRDUP) */
  23
  24 /*
  25 **  strcmp-like sorting predicate for qsort.
  26 */
  27 STATIC int
  28 compare(p1, p2)
  29     CONST void  *p1;
  30     CONST void  *p2;
  31 {
  32     CONST char  **v1;
  33     CONST char  **v2;
  34
  35     v1 = (CONST char **)p1;
  36     v2 = (CONST char **)p2;
  37     return strcmp(*v1, *v2);
  38 }
  39
  40 /*
  41 **  Fill in *avp with an array of names that match file, up to its length.
  42 **  Ignore . and .. .
  43 */
  44 STATIC int
  45 FindMatches(dir, file, avp)
  46     char        *dir;
  47     char        *file;
  48     char        ***avp;
  49 {
  50     char        **av;
  51     char        **new;
  52     char        *p;
  53     DIR         *dp;
  54     DIRENTRY    *ep;
  55     SIZE_T      ac;
  56     SIZE_T      len;
  57     SIZE_T      choices;
  58     SIZE_T      total;
  59 #define MAX_TOTAL       (256 << sizeof(char *))
  60
  61     if ((dp = opendir(dir)) == NULL)
  62         return 0;
  63
  64     av = NULL;
  65     ac = 0;
  66     len = strlen(file);
  67     choices = 0;
  68     total = 0;
  69     while ((ep = readdir(dp)) != NULL) {
  70         p = ep->d_name;
  71         if (p[0] == '.' && (p[1] == '\0' || (p[1] == '.' && p[2] == '\0')))
  72             continue;
  73         if (len && strncmp(p, file, len) != 0)
  74             continue;
  75
  76         choices++;
  77         if ((total += strlen(p)) > MAX_TOTAL) {
  78             /* This is a bit too much. */
  79             while (ac > 0) DISPOSE(av[--ac]);
  80             continue;
  81         }
  82
  83         if ((ac % MEM_INC) == 0) {
  84             if ((new = NEW(char*, ac + MEM_INC)) == NULL) {
  85                 total = 0;
  86                 break;
  87             }
  88             if (ac) {
  89                 COPYFROMTO(new, av, ac * sizeof (char **));
  90                 DISPOSE(av);
  91             }
  92             *avp = av = new;
  93         }
  94
  95         if ((av[ac] = strdup(p)) == NULL) {
  96             if (ac == 0)
  97                 DISPOSE(av);
  98             total = 0;
  99             break;
 100         }
 101         ac++;
 102     }
 103
 104     /* Clean up and return. */
 105     (void)closedir(dp);
 106     if (total > MAX_TOTAL) {
 107         char many[sizeof(total) * 3];
 108         p = many + sizeof(many);
 109         *--p = '\0';
 110         while (choices > 0) {
 111            *--p = '0' + choices % 10;
 112            choices /= 10;
 113         }
 114         while (p > many + sizeof(many) - 8) *--p = ' ';
 115         if ((p = strdup(p)) != NULL) av[ac++] = p;
 116         if ((p = strdup("choices")) != NULL) av[ac++] = p;
 117     } else {
 118         if (ac)
 119             qsort(av, ac, sizeof (char **), compare);
 120     }
 121     return ac;
 122 }
 123
 124 /*
 125 **  Split a pathname into allocated directory and trailing filename parts.
 126 */
 127 STATIC int
 128 SplitPath(path, dirpart, filepart)
 129     char        *path;
 130     char        **dirpart;
 131     char        **filepart;
 132 {
 133     static char DOT[] = ".";
 134     char        *dpart;
 135     char        *fpart;
 136
 137     if ((fpart = strrchr(path, '/')) == NULL) {
 138         if ((dpart = strdup(DOT)) == NULL)
 139             return -1;
 140         if ((fpart = strdup(path)) == NULL) {
 141             DISPOSE(dpart);
 142             return -1;
 143         }
 144     }
 145     else {
 146         if ((dpart = strdup(path)) == NULL)
 147             return -1;
 148         dpart[fpart - path + 1] = '\0';
 149         if ((fpart = strdup(++fpart)) == NULL) {
 150             DISPOSE(dpart);
 151             return -1;
 152         }
 153     }
 154     *dirpart = dpart;
 155     *filepart = fpart;
 156     return 0;
 157 }
 158
 159 /*
 160 **  Attempt to complete the pathname, returning an allocated copy.
 161 **  Fill in *unique if we completed it, or set it to 0 if ambiguous.
 162 */
 163 char *
 164 rl_complete(pathname, unique)
 165     char        *pathname;
 166     int         *unique;
 167 {
 168     char        **av;
 169     char        *dir;
 170     char        *file;
 171     char        *new;
 172     char        *p;
 173     SIZE_T      ac;
 174     SIZE_T      end;
 175     SIZE_T      i;
 176     SIZE_T      j;
 177     SIZE_T      len;
 178
 179     if (SplitPath(pathname, &dir, &file) < 0)
 180         return NULL;
 181     if ((ac = FindMatches(dir, file, &av)) == 0) {
 182         DISPOSE(dir);
 183         DISPOSE(file);
 184         return NULL;
 185     }
 186
 187     p = NULL;
 188     len = strlen(file);
 189     if (ac == 1) {
 190         /* Exactly one match -- finish it off. */
 191         *unique = 1;
 192         j = strlen(av[0]) - len + 2;
 193         if ((p = NEW(char, j + 1)) != NULL) {
 194             COPYFROMTO(p, av[0] + len, j);
 195             if ((new = NEW(char, strlen(dir) + strlen(av[0]) + 2)) != NULL) {
 196                 (void)strcpy(new, dir);
 197                 (void)strcat(new, "/");
 198                 (void)strcat(new, av[0]);
 199                 rl_add_slash(new, p);
 200                 DISPOSE(new);
 201             }
 202         }
 203     }
 204     else {
 205         *unique = 0;
 206         if (len) {
 207             /* Find largest matching substring. */
 208             for (i = len, end = strlen(av[0]); i < end; i++)
 209                 for (j = 1; j < ac; j++)
 210                     if (av[0][i] != av[j][i])
 211                         goto breakout;
 212   breakout:
 213             if (i > len) {
 214                 j = i - len + 1;
 215                 if ((p = NEW(char, j)) != NULL) {
 216                     COPYFROMTO(p, av[0] + len, j);
 217                     p[j - 1] = '\0';
 218                 }
 219             }
 220         }
 221     }
 222
 223     /* Clean up and return. */
 224     DISPOSE(dir);
 225     DISPOSE(file);
 226     for (i = 0; i < ac; i++)
 227         DISPOSE(av[i]);
 228     DISPOSE(av);
 229     return p;
 230 }
 231
 232 /*
 233 **  Return all possible completions.
 234 */
 235 int
 236 rl_list_possib(pathname, avp)
 237     char        *pathname;
 238     char        ***avp;
 239 {
 240     char        *dir;
 241     char        *file;
 242     int         ac;
 243
 244     if (SplitPath(pathname, &dir, &file) < 0)
 245         return 0;
 246     ac = FindMatches(dir, file, avp);
 247     DISPOSE(dir);
 248     DISPOSE(file);
 249     return ac;
 250 }
 251
 252 /*
 253  * $PchId: complete.c,v 1.3 1996/02/22 21:18:51 philip Exp $
 254  */