Changeset 133


Ignore:
Timestamp:
Jun 3, 2010, 7:36:15 PM (5 years ago)
Author:
stepan
Message:

initial tab completion support. device matching fails, so only commands can be completed so far.
Signed-off-by: Stefan Reinauer <stepan@…>

Location:
trunk/filo
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/filo/fs/vfs.c

    r105 r133  
    241241        devclose(); 
    242242} 
     243 
     244int dir(char *dirname) 
     245{ 
     246        char *dev = 0; 
     247        const char *path; 
     248        int len; 
     249        int retval = 0; 
     250        int reopen; 
     251 
     252        path = strchr(dirname, ':'); 
     253        if (path) { 
     254                len = path - dirname; 
     255                path++; 
     256                dev = malloc(len + 1); 
     257                memcpy(dev, dirname, len); 
     258                dev[len] = '\0'; 
     259        } else { 
     260                /* No colon is given. Is this device or dirname? */ 
     261                if (dirname[0] == '/') { 
     262                        /* Anything starts with '/' must be a dirname */ 
     263                        dev = 0; 
     264                        path = dirname; 
     265                } else { 
     266                        dev = strdup(dirname); 
     267                        path = 0; 
     268                } 
     269        } 
     270        debug("dev=%s, path=%s\n", dev, path); 
     271 
     272        if (dev && dev[0]) { 
     273                if (!devopen(dev, &reopen)) { 
     274                        fsys = 0; 
     275                        goto out; 
     276                } 
     277                if (!reopen) 
     278                        fsys = 0; 
     279        } 
     280 
     281        if (path) { 
     282                if (!fsys || fsys == &nullfs) { 
     283                        if (!mount_fs()) 
     284                                goto out; 
     285                } 
     286                using_devsize = 0; 
     287                if (!path[0]) { 
     288                        printf("No dirname is given.\n"); 
     289                        goto out; 
     290                } 
     291        } else { 
     292                fsys = &nullfs; 
     293        } 
     294 
     295        filepos = 0; 
     296        errnum = 0; 
     297 
     298        /* set "dir" function to list completions */ 
     299        print_possibilities = 1; 
     300 
     301        retval = fsys->dir_func((char *) path); 
     302 
     303out: 
     304        if (dev) 
     305                free(dev); 
     306 
     307        return retval; 
     308} 
     309 
     310 
  • trunk/filo/main/grub/completions.c

    r103 r133  
    2323#include <config.h> 
    2424#include <grub/shared.h> 
     25#define current_slice 0 
    2526 
    2627static int do_completion; 
     
    2829static char *unique_string; 
    2930 
     31static int incomplete, disk_choice; 
     32static enum 
     33{ 
     34        PART_UNSPECIFIED = 0, 
     35        PART_DISK, 
     36        PART_CHOSEN, 
     37} part_choice; 
     38 
     39int 
     40real_open_partition (int flags) 
     41{ 
     42        errnum = ERR_NONE; 
     43        return 1; 
     44} 
     45 
     46int 
     47open_partition (void) 
     48{ 
     49        return real_open_partition (0); 
     50} 
     51 
     52char * 
     53set_device (char *device) 
     54{ 
     55        int result = 0; 
     56 
     57        if (result) { 
     58                return device + 1; 
     59        } else { 
     60                if (!*device) 
     61                        incomplete = 1; 
     62                errnum = ERR_DEV_FORMAT; 
     63        } 
     64        return 0; 
     65} 
    3066 
    3167/* If DO_COMPLETION is true, just print NAME. Otherwise save the unique 
     
    6399int print_completions(int is_filename, int is_completion) 
    64100{ 
    65 #ifdef CONFIG_EXPERIMENTAL 
    66101        char *buf = (char *) COMPLETION_BUF; 
    67102        char *ptr = buf; 
     
    72107        do_completion = is_completion; 
    73108 
    74 #warning FIXME implement print_completions 
    75         // FIXME: This function is a dummy, returning an error. 
    76         errnum = ERR_BAD_FILENAME; 
    77  
     109        if (!is_filename) { 
     110                /* Print the completions of builtin commands.  */ 
     111                struct builtin **builtin; 
     112 
     113                if (!is_completion) 
     114                        grub_printf (" Possible commands are:"); 
     115 
     116                for (builtin = builtin_table; (*builtin); builtin++) { 
     117                        /* If *builtin cannot be run in the command-line, skip it. */ 
     118                        if (!((*builtin)->flags & BUILTIN_CMDLINE)) 
     119                                continue; 
     120                        if (substring (buf, (*builtin)->name) <= 0) 
     121                                print_a_completion ((*builtin)->name); 
     122                } 
     123 
     124                if (is_completion && *unique_string) { 
     125                        if (unique == 1) { 
     126                                char *u = unique_string + strlen (unique_string); 
     127                                *u++ = ' '; 
     128                                *u = 0; 
     129                        } 
     130                        strcpy (buf, unique_string); 
     131                } 
     132 
     133                if (!is_completion) 
     134                        grub_putchar ('\n'); 
     135 
     136                print_error(); 
     137                do_completion = 0; 
     138                if (errnum) 
     139                        return -1; 
     140                else 
     141                        return unique - 1; 
     142        } 
     143 
     144        if (*buf == '/' || (ptr = set_device (buf)) || incomplete) { 
     145                errnum = 0; 
     146                if (*buf == '(' && (incomplete || ! *ptr)) { 
     147                        if (!part_choice) { 
     148                                /* disk completions */ 
     149                                int disk_no, i, j; 
     150 
     151                                if (!is_completion) 
     152                                        grub_printf (" Possible disks are: "); 
     153 
     154                                if (!ptr 
     155                                        || *(ptr-1) != 'd' 
     156                                        || *(ptr-2) != 'n' /* netboot? */ 
     157                                        || *(ptr-2) != 'c') { 
     158                                        for (i = (ptr && (*(ptr-1) == 'd' && *(ptr-2) == 'h') ? 1:0); 
     159                                             i < (ptr && (*(ptr-1) == 'd' && *(ptr-2) == 'f') ?  1:2); 
     160                                             i++) { 
     161                                                for (j = 0; j < 8; j++) { 
     162                                                        if ((disk_choice)) { // TODO check geometry 
     163                                                                char dev_name[8]; 
     164                                                                sprintf (dev_name, "%cd%d", i ?  'h':'f', j); 
     165                                                                print_a_completion(dev_name); 
     166                                                        } 
     167                                                } 
     168                                        } 
     169                                } 
     170 
     171#if 0 
     172                                if (cdrom_drive != GRUB_INVALID_DRIVE 
     173                                    && (disk_choice || cdrom_drive == current_drive) 
     174                                    && (!ptr 
     175                                        || *(ptr-1) == '(' 
     176                                        || (*(ptr-1) == 'd' && *(ptr-2) == 'c'))) 
     177                                        print_a_completion("cd"); 
     178#endif 
     179 
     180                                if (is_completion && *unique_string) { 
     181                                        ptr = buf; 
     182                                        while (*ptr != '(') 
     183                                                ptr--; 
     184                                        ptr++; 
     185                                        strcpy (ptr, unique_string); 
     186                                        if (unique == 1) { 
     187                                                ptr += strlen (ptr); 
     188                                                if (*unique_string == 'h') { 
     189                                                        *ptr++ = ','; 
     190                                                        *ptr = 0; 
     191                                                } else { 
     192                                                        *ptr++ = ')'; 
     193                                                        *ptr = 0; 
     194                                                } 
     195                                        } 
     196                                } 
     197 
     198                                if (!is_completion) 
     199                                        grub_putchar('\n'); 
     200                        } else { 
     201                                /* Partition completions */ 
     202                                if (part_choice == PART_CHOSEN 
     203                                    && open_partition() 
     204                                    && ! IS_PC_SLICE_TYPE_BSD(current_slice)) { 
     205                                        unique = 1; 
     206                                        ptr = buf + strlen(buf); 
     207                                        if (*(ptr - 1) != ')') { 
     208                                                *ptr++ = ')'; 
     209                                                *ptr = 0; 
     210                                        } 
     211                                } else { 
     212                                        if (!is_completion) 
     213                                                grub_printf (" Possible partitions are:\n"); 
     214                                        real_open_partition(1); 
     215                                        if (is_completion && *unique_string) { 
     216                                                ptr = buf; 
     217                                                while (*ptr++ != ',') 
     218                                                        ; 
     219                                                strcpy (ptr, unique_string); 
     220                                        } 
     221                                } 
     222                        } 
     223                } else if (ptr && *ptr == '/') { 
     224                        /* filename completions */ 
     225                        if (!is_completion) 
     226                                grub_printf (" Possible files are:"); 
     227                        dir(buf); 
     228 
     229                        if (is_completion && *unique_string) { 
     230                                ptr += strlen (ptr); 
     231                                while (*ptr != '/') 
     232                                        ptr--; 
     233                                ptr++; 
     234 
     235                                strcpy(ptr, unique_string); 
     236 
     237                                if (unique == 1) { 
     238                                        ptr += strlen (unique_string); 
     239 
     240                                        /* Check if the file UNIQUE_STRING is a directory.  */ 
     241                                        *ptr = '/'; 
     242                                        *(ptr + 1) = 0; 
     243 
     244                                        dir (buf); 
     245 
     246                                        /* Restore the original unique value. */ 
     247                                        unique = 1; 
     248 
     249                                        if (errnum) { 
     250                                                /* regular file */ 
     251                                                errnum = 0; 
     252                                                *ptr = ' '; 
     253                                                *(ptr + 1) = 0; 
     254                                        } 
     255                                } 
     256                        } 
     257 
     258                        if (!is_completion) 
     259                                grub_putchar ('\n'); 
     260 
     261                } else { 
     262                        errnum = ERR_BAD_FILENAME; 
     263                } 
     264        } 
    78265 
    79266        print_error(); 
     
    83270        else 
    84271                return unique - 1; 
    85 #else 
    86         errnum = ERR_BAD_FILENAME; 
    87         print_error(); 
    88         return -1; 
    89 #endif 
    90 } 
     272} 
Note: See TracChangeset for help on using the changeset viewer.