| /* | |
| * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>. | |
| * | |
| * This program 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 2 of the | |
| * License, or any later version. | |
| * | |
| * This program 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 this program; if not, write to the Free Software | |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA | |
| * 02110-1301, USA. | |
| * | |
| * You can also choose to distribute this program under the terms of | |
| * the Unmodified Binary Distribution Licence (as given in the file | |
| * COPYING.UBDL), provided that you have satisfied its requirements. | |
| */ | |
| FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL ); | |
| FILE_SECBOOT ( PERMITTED ); | |
| #include <stdio.h> | |
| #include <string.h> | |
| #include <stdlib.h> | |
| #include <errno.h> | |
| #include <ipxe/console.h> | |
| #include <ipxe/keys.h> | |
| #include <ipxe/editstring.h> | |
| #include <readline/readline.h> | |
| /** @file | |
| * | |
| * Minimal readline | |
| * | |
| */ | |
| /** | |
| * Synchronise console with edited string | |
| * | |
| * @v string Editable string | |
| */ | |
| static void sync_console ( struct edit_string *string ) { | |
| unsigned int mod_start = string->mod_start; | |
| unsigned int mod_end = string->mod_end; | |
| unsigned int cursor = string->last_cursor; | |
| const char *buf = *(string->buf); | |
| size_t len = strlen ( buf ); | |
| /* Expand region back to old cursor position if applicable */ | |
| if ( mod_start > string->last_cursor ) | |
| mod_start = string->last_cursor; | |
| /* Expand region forward to new cursor position if applicable */ | |
| if ( mod_end < string->cursor ) | |
| mod_end = string->cursor; | |
| /* Backspace to start of region */ | |
| while ( cursor > mod_start ) { | |
| putchar ( '\b' ); | |
| cursor--; | |
| } | |
| /* Print modified region */ | |
| while ( cursor < mod_end ) { | |
| putchar ( ( cursor >= len ) ? ' ' : buf[cursor] ); | |
| cursor++; | |
| } | |
| /* Backspace to new cursor position */ | |
| while ( cursor > string->cursor ) { | |
| putchar ( '\b' ); | |
| cursor--; | |
| } | |
| } | |
| /** | |
| * Locate history entry | |
| * | |
| * @v history History buffer | |
| * @v depth Depth within history buffer | |
| * @ret entry History entry | |
| */ | |
| static struct readline_history_entry * | |
| history_entry ( struct readline_history *history, unsigned int depth ) { | |
| unsigned int offset; | |
| offset = ( ( history->next - depth ) % | |
| ( sizeof ( history->entries ) / | |
| sizeof ( history->entries[0] ) ) ); | |
| return &history->entries[offset]; | |
| } | |
| /** | |
| * Read string from history buffer | |
| * | |
| * @v history History buffer | |
| * @v depth Depth within history buffer | |
| * @ret string String | |
| */ | |
| static const char * history_fetch ( struct readline_history *history, | |
| unsigned int depth ) { | |
| struct readline_history_entry *entry; | |
| /* Return the temporary copy if it exists, otherwise return | |
| * the persistent copy. | |
| */ | |
| entry = history_entry ( history, depth ); | |
| return ( entry->temp ? entry->temp : entry->string ); | |
| } | |
| /** | |
| * Write temporary string copy to history buffer | |
| * | |
| * @v history History buffer | |
| * @v depth Depth within history buffer | |
| * @v string String | |
| */ | |
| static void history_store ( struct readline_history *history, | |
| unsigned int depth, const char *string ) { | |
| struct readline_history_entry *entry; | |
| char *temp; | |
| /* Create temporary copy of string */ | |
| temp = strdup ( string ); | |
| if ( ! temp ) { | |
| /* Just discard the string; there's nothing we can do */ | |
| DBGC ( history, "READLINE %p could not store string\n", | |
| history ); | |
| return; | |
| } | |
| /* Store temporary copy */ | |
| entry = history_entry ( history, depth ); | |
| free ( entry->temp ); | |
| entry->temp = temp; | |
| } | |
| /** | |
| * Move to new history depth | |
| * | |
| * @v history History buffer | |
| * @v offset Offset by which to change depth | |
| * @v old_string String (possibly modified) at current depth | |
| * @ret new_string String at new depth, or NULL for no movement | |
| */ | |
| static const char * history_move ( struct readline_history *history, | |
| int offset, const char *old_string ) { | |
| unsigned int new_depth = ( history->depth + offset ); | |
| const char * new_string = history_fetch ( history, new_depth ); | |
| /* Depth checks */ | |
| if ( new_depth > READLINE_HISTORY_MAX_DEPTH ) | |
| return NULL; | |
| if ( ! new_string ) | |
| return NULL; | |
| /* Store temporary copy of old string at current depth */ | |
| history_store ( history, history->depth, old_string ); | |
| /* Update depth */ | |
| history->depth = new_depth; | |
| /* Return new string */ | |
| return new_string; | |
| } | |
| /** | |
| * Append new history entry | |
| * | |
| * @v history History buffer | |
| * @v string String | |
| */ | |
| static void history_append ( struct readline_history *history, | |
| const char *string ) { | |
| struct readline_history_entry *entry; | |
| /* Store new entry */ | |
| entry = history_entry ( history, 0 ); | |
| assert ( entry->string == NULL ); | |
| entry->string = strdup ( string ); | |
| if ( ! entry->string ) { | |
| /* Just discard the string; there's nothing we can do */ | |
| DBGC ( history, "READLINE %p could not append string\n", | |
| history ); | |
| return; | |
| } | |
| /* Increment history position */ | |
| history->next++; | |
| /* Prepare empty "next" slot */ | |
| entry = history_entry ( history, 0 ); | |
| free ( entry->string ); | |
| entry->string = NULL; | |
| } | |
| /** | |
| * Clean up history after editing | |
| * | |
| * @v history History buffer | |
| */ | |
| static void history_cleanup ( struct readline_history *history ) { | |
| struct readline_history_entry *entry; | |
| unsigned int i; | |
| /* Discard any temporary strings */ | |
| for ( i = 0 ; i < ( sizeof ( history->entries ) / | |
| sizeof ( history->entries[0] ) ) ; i++ ) { | |
| entry = &history->entries[i]; | |
| free ( entry->temp ); | |
| entry->temp = NULL; | |
| } | |
| /* Reset depth */ | |
| history->depth = 0; | |
| /* Sanity check */ | |
| entry = history_entry ( history, 0 ); | |
| assert ( entry->string == NULL ); | |
| } | |
| /** | |
| * Free history buffer | |
| * | |
| * @v history History buffer | |
| */ | |
| void history_free ( struct readline_history *history ) { | |
| struct readline_history_entry *entry; | |
| unsigned int i; | |
| /* Discard any temporary strings */ | |
| for ( i = 0 ; i < ( sizeof ( history->entries ) / | |
| sizeof ( history->entries[0] ) ) ; i++ ) { | |
| entry = &history->entries[i]; | |
| assert ( entry->temp == NULL ); | |
| free ( entry->string ); | |
| } | |
| } | |
| /** | |
| * Read line from console (with history) | |
| * | |
| * @v prompt Prompt string | |
| * @v prefill Prefill string, or NULL for no prefill | |
| * @v history History buffer, or NULL for no history | |
| * @v timeout Timeout period, in ticks (0=indefinite) | |
| * @ret line Line read from console (excluding terminating newline) | |
| * @ret rc Return status code | |
| * | |
| * The returned line is allocated with malloc(); the caller must | |
| * eventually call free() to release the storage. | |
| */ | |
| int readline_history ( const char *prompt, const char *prefill, | |
| struct readline_history *history, unsigned long timeout, | |
| char **line ) { | |
| struct edit_string string; | |
| int key; | |
| int move_by; | |
| const char *new_string; | |
| int rc; | |
| /* Display prompt, if applicable */ | |
| if ( prompt ) | |
| printf ( "%s", prompt ); | |
| /* Ensure cursor is visible */ | |
| printf ( "\033[?25h" ); | |
| /* Initialise editable string */ | |
| *line = NULL; | |
| memset ( &string, 0, sizeof ( string ) ); | |
| init_editstring ( &string, line ); | |
| /* Prefill string */ | |
| if ( ( rc = replace_string ( &string, prefill ) ) != 0 ) | |
| goto error; | |
| sync_console ( &string ); | |
| while ( 1 ) { | |
| /* Get keypress */ | |
| key = getkey ( timeout ); | |
| if ( key < 0 ) { | |
| rc = -ETIMEDOUT; | |
| goto error; | |
| } | |
| timeout = 0; | |
| /* Handle keypress */ | |
| key = edit_string ( &string, key ); | |
| sync_console ( &string ); | |
| move_by = 0; | |
| switch ( key ) { | |
| case CR: | |
| case LF: | |
| rc = 0; | |
| goto done; | |
| case CTRL_C: | |
| rc = -ECANCELED; | |
| goto error; | |
| case KEY_UP: | |
| move_by = 1; | |
| break; | |
| case KEY_DOWN: | |
| move_by = -1; | |
| break; | |
| default: | |
| /* Do nothing for unrecognised keys or edit errors */ | |
| break; | |
| } | |
| /* Handle history movement, if applicable */ | |
| if ( move_by && history ) { | |
| new_string = history_move ( history, move_by, *line ); | |
| if ( new_string ) { | |
| replace_string ( &string, new_string ); | |
| sync_console ( &string ); | |
| } | |
| } | |
| } | |
| error: | |
| free ( *line ); | |
| *line = NULL; | |
| done: | |
| putchar ( '\n' ); | |
| if ( history ) { | |
| if ( *line && (*line)[0] ) | |
| history_append ( history, *line ); | |
| history_cleanup ( history ); | |
| } | |
| assert ( ( rc == 0 ) ^ ( *line == NULL ) ); | |
| return rc; | |
| } | |
| /** | |
| * Read line from console | |
| * | |
| * @v prompt Prompt string | |
| * @ret line Line read from console (excluding terminating newline) | |
| * | |
| * The returned line is allocated with malloc(); the caller must | |
| * eventually call free() to release the storage. | |
| */ | |
| char * readline ( const char *prompt ) { | |
| char *line; | |
| readline_history ( prompt, NULL, NULL, 0, &line ); | |
| return line; | |
| } |