src/hci/readline.c

   1 /*
   2  * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17  * 02110-1301, USA.
  18  *
  19  * You can also choose to distribute this program under the terms of
  20  * the Unmodified Binary Distribution Licence (as given in the file
  21  * COPYING.UBDL), provided that you have satisfied its requirements.
  22  */
  23
  24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <stdlib.h>
  29 #include <errno.h>
  30 #include <ipxe/console.h>
  31 #include <ipxe/keys.h>
  32 #include <ipxe/editstring.h>
  33 #include <readline/readline.h>
  34
  35 /** @file
  36  *
  37  * Minimal readline
  38  *
  39  */
  40
  41 #define READLINE_MAX 256
  42
  43 /**
  44  * Synchronise console with edited string
  45  *
  46  * @v string            Editable string
  47  */
  48 static void sync_console ( struct edit_string *string ) {
  49         unsigned int mod_start = string->mod_start;
  50         unsigned int mod_end = string->mod_end;
  51         unsigned int cursor = string->last_cursor;
  52         size_t len = strlen ( string->buf );
  53
  54         /* Expand region back to old cursor position if applicable */
  55         if ( mod_start > string->last_cursor )
  56                 mod_start = string->last_cursor;
  57
  58         /* Expand region forward to new cursor position if applicable */
  59         if ( mod_end < string->cursor )
  60                 mod_end = string->cursor;
  61
  62         /* Backspace to start of region */
  63         while ( cursor > mod_start ) {
  64                 putchar ( '\b' );
  65                 cursor--;
  66         }
  67
  68         /* Print modified region */
  69         while ( cursor < mod_end ) {
  70                 putchar ( ( cursor >= len ) ? ' ' : string->buf[cursor] );
  71                 cursor++;
  72         }
  73
  74         /* Backspace to new cursor position */
  75         while ( cursor > string->cursor ) {
  76                 putchar ( '\b' );
  77                 cursor--;
  78         }
  79 }
  80
  81 /**
  82  * Locate history entry
  83  *
  84  * @v history           History buffer
  85  * @v depth             Depth within history buffer
  86  * @ret entry           History entry
  87  */
  88 static struct readline_history_entry *
  89 history_entry ( struct readline_history *history, unsigned int depth ) {
  90         unsigned int offset;
  91
  92         offset = ( ( history->next - depth ) %
  93                    ( sizeof ( history->entries ) /
  94                      sizeof ( history->entries[0] ) ) );
  95         return &history->entries[offset];
  96 }
  97
  98 /**
  99  * Read string from history buffer
 100  *
 101  * @v history           History buffer
 102  * @v depth             Depth within history buffer
 103  * @ret string          String
 104  */
 105 static const char * history_fetch ( struct readline_history *history,
 106                                     unsigned int depth ) {
 107         struct readline_history_entry *entry;
 108
 109         /* Return the temporary copy if it exists, otherwise return
 110          * the persistent copy.
 111          */
 112         entry = history_entry ( history, depth );
 113         return ( entry->temp ? entry->temp : entry->string );
 114 }
 115
 116 /**
 117  * Write temporary string copy to history buffer
 118  *
 119  * @v history           History buffer
 120  * @v depth             Depth within history buffer
 121  * @v string            String
 122  */
 123 static void history_store ( struct readline_history *history,
 124                             unsigned int depth, const char *string ) {
 125         struct readline_history_entry *entry;
 126         char *temp;
 127
 128         /* Create temporary copy of string */
 129         temp = strdup ( string );
 130         if ( ! temp ) {
 131                 /* Just discard the string; there's nothing we can do */
 132                 DBGC ( history, "READLINE %p could not store string\n",
 133                        history );
 134                 return;
 135         }
 136
 137         /* Store temporary copy */
 138         entry = history_entry ( history, depth );
 139         free ( entry->temp );
 140         entry->temp = temp;
 141 }
 142
 143 /**
 144  * Move to new history depth
 145  *
 146  * @v history           History buffer
 147  * @v offset            Offset by which to change depth
 148  * @v old_string        String (possibly modified) at current depth
 149  * @ret new_string      String at new depth, or NULL for no movement
 150  */
 151 static const char * history_move ( struct readline_history *history,
 152                                    int offset, const char *old_string ) {
 153         unsigned int new_depth = ( history->depth + offset );
 154         const char * new_string = history_fetch ( history, new_depth );
 155
 156         /* Depth checks */
 157         if ( new_depth > READLINE_HISTORY_MAX_DEPTH )
 158                 return NULL;
 159         if ( ! new_string )
 160                 return NULL;
 161
 162         /* Store temporary copy of old string at current depth */
 163         history_store ( history, history->depth, old_string );
 164
 165         /* Update depth */
 166         history->depth = new_depth;
 167
 168         /* Return new string */
 169         return new_string;
 170 }
 171
 172 /**
 173  * Append new history entry
 174  *
 175  * @v history           History buffer
 176  * @v string            String
 177  */
 178 static void history_append ( struct readline_history *history,
 179                              const char *string ) {
 180         struct readline_history_entry *entry;
 181
 182         /* Store new entry */
 183         entry = history_entry ( history, 0 );
 184         assert ( entry->string == NULL );
 185         entry->string = strdup ( string );
 186         if ( ! entry->string ) {
 187                 /* Just discard the string; there's nothing we can do */
 188                 DBGC ( history, "READLINE %p could not append string\n",
 189                        history );
 190                 return;
 191         }
 192
 193         /* Increment history position */
 194         history->next++;
 195
 196         /* Prepare empty "next" slot */
 197         entry = history_entry ( history, 0 );
 198         free ( entry->string );
 199         entry->string = NULL;
 200 }
 201
 202 /**
 203  * Clean up history after editing
 204  *
 205  * @v history           History buffer
 206  */
 207 static void history_cleanup ( struct readline_history *history ) {
 208         struct readline_history_entry *entry;
 209         unsigned int i;
 210
 211         /* Discard any temporary strings */
 212         for ( i = 0 ; i < ( sizeof ( history->entries ) /
 213                             sizeof ( history->entries[0] ) ) ; i++ ) {
 214                 entry = &history->entries[i];
 215                 free ( entry->temp );
 216                 entry->temp = NULL;
 217         }
 218
 219         /* Reset depth */
 220         history->depth = 0;
 221
 222         /* Sanity check */
 223         entry = history_entry ( history, 0 );
 224         assert ( entry->string == NULL );
 225 }
 226
 227 /**
 228  * Free history buffer
 229  *
 230  * @v history           History buffer
 231  */
 232 void history_free ( struct readline_history *history ) {
 233         struct readline_history_entry *entry;
 234         unsigned int i;
 235
 236         /* Discard any temporary strings */
 237         for ( i = 0 ; i < ( sizeof ( history->entries ) /
 238                             sizeof ( history->entries[0] ) ) ; i++ ) {
 239                 entry = &history->entries[i];
 240                 assert ( entry->temp == NULL );
 241                 free ( entry->string );
 242         }
 243 }
 244
 245 /**
 246  * Read line from console (with history)
 247  *
 248  * @v prompt            Prompt string
 249  * @v prefill           Prefill string, or NULL for no prefill
 250  * @v history           History buffer, or NULL for no history
 251  * @ret line            Line read from console (excluding terminating newline)
 252  * @ret rc              Return status code
 253  *
 254  * The returned line is allocated with malloc(); the caller must
 255  * eventually call free() to release the storage.
 256  */
 257 int readline_history ( const char *prompt, const char *prefill,
 258                        struct readline_history *history, char **line ) {
 259         char buf[READLINE_MAX];
 260         struct edit_string string;
 261         int key;
 262         int move_by;
 263         const char *new_string;
 264         int rc;
 265
 266         /* Avoid returning uninitialised data on error */
 267         *line = NULL;
 268
 269         /* Display prompt, if applicable */
 270         if ( prompt )
 271                 printf ( "%s", prompt );
 272
 273         /* Ensure cursor is visible */
 274         printf ( "\033[?25h" );
 275
 276         /* Initialise editable string */
 277         memset ( &string, 0, sizeof ( string ) );
 278         init_editstring ( &string, buf, sizeof ( buf ) );
 279         buf[0] = '\0';
 280
 281         /* Prefill string, if applicable */
 282         if ( prefill ) {
 283                 replace_string ( &string, prefill );
 284                 sync_console ( &string );
 285         }
 286
 287         while ( 1 ) {
 288                 /* Handle keypress */
 289                 key = edit_string ( &string, getkey ( 0 ) );
 290                 sync_console ( &string );
 291                 move_by = 0;
 292                 switch ( key ) {
 293                 case CR:
 294                 case LF:
 295                         *line = strdup ( buf );
 296                         rc = ( ( *line ) ? 0 : -ENOMEM );
 297                         goto done;
 298                 case CTRL_C:
 299                         rc = -ECANCELED;
 300                         goto done;
 301                 case KEY_UP:
 302                         move_by = 1;
 303                         break;
 304                 case KEY_DOWN:
 305                         move_by = -1;
 306                         break;
 307                 default:
 308                         /* Do nothing */
 309                         break;
 310                 }
 311
 312                 /* Handle history movement, if applicable */
 313                 if ( move_by && history ) {
 314                         new_string = history_move ( history, move_by, buf );
 315                         if ( new_string ) {
 316                                 replace_string ( &string, new_string );
 317                                 sync_console ( &string );
 318                         }
 319                 }
 320         }
 321
 322  done:
 323         putchar ( '\n' );
 324         if ( history ) {
 325                 if ( *line && (*line)[0] )
 326                         history_append ( history, *line );
 327                 history_cleanup ( history );
 328         }
 329         assert ( ( rc == 0 ) ^ ( *line == NULL ) );
 330         return rc;
 331 }
 332
 333 /**
 334  * Read line from console
 335  *
 336  * @v prompt            Prompt string
 337  * @ret line            Line read from console (excluding terminating newline)
 338  *
 339  * The returned line is allocated with malloc(); the caller must
 340  * eventually call free() to release the storage.
 341  */
 342 char * readline ( const char *prompt ) {
 343         char *line;
 344
 345         readline_history ( prompt, NULL, NULL, &line );
 346         return line;
 347 }