readline.c File Reference

Minimal readline. More...

#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>

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static void	sync_console (struct edit_string *string)
	Synchronise console with edited string.
static struct readline_history_entry *	history_entry (struct readline_history *history, unsigned int depth)
	Locate history entry.
static const char *	history_fetch (struct readline_history *history, unsigned int depth)
	Read string from history buffer.
static void	history_store (struct readline_history *history, unsigned int depth, const char *string)
	Write temporary string copy to history buffer.
static const char *	history_move (struct readline_history *history, int offset, const char *old_string)
	Move to new history depth.
static void	history_append (struct readline_history *history, const char *string)
	Append new history entry.
static void	history_cleanup (struct readline_history *history)
	Clean up history after editing.
void	history_free (struct readline_history *history)
	Free history buffer.
int	readline_history (const char *prompt, const char *prefill, struct readline_history *history, unsigned long timeout, char **line)
	Read line from console (with history)
char *	readline (const char *prompt)
	Read line from console.

Detailed Description

Minimal readline.

Definition in file readline.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

sync_console()

void sync_console ( struct edit_string * string )

static

Synchronise console with edited string.

Parameters

string

Editable string

Definition at line 47 of file readline.c.

                                                        {
        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--;
        }
}

References len, mod_end, mod_start, putchar(), string, and strlen().

Referenced by readline_history().

history_entry()

struct readline_history_entry * history_entry ( struct readline_history * history, unsigned int depth )

static

Locate history entry.

Parameters

history	History buffer
depth	Depth within history buffer

Return values

entry

History entry

Definition at line 89 of file readline.c.

                                                                       {
        unsigned int offset;
 
        offset = ( ( history->next - depth ) %
                   ( sizeof ( history->entries ) /
                     sizeof ( history->entries[0] ) ) );
        return &history->entries[offset];
}

References readline_history::entries, readline_history::next, and offset.

Referenced by history_append(), history_cleanup(), history_fetch(), and history_store().

history_fetch()

const char * history_fetch ( struct readline_history * history, unsigned int depth )

static

Read string from history buffer.

Parameters

history	History buffer
depth	Depth within history buffer

Return values

string

String

Definition at line 105 of file readline.c.

                                                         {
        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 );
}

References history_entry(), readline_history_entry::string, and readline_history_entry::temp.

Referenced by history_move().

history_store()

void history_store ( struct readline_history * history, unsigned int depth, const char * string )

static

Write temporary string copy to history buffer.

Parameters

history	History buffer
depth	Depth within history buffer
string	String

Definition at line 123 of file readline.c.

                                                                     {
        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;
}

References DBGC, free, history_entry(), strdup(), and readline_history_entry::temp.

Referenced by history_move().

history_move()

const char * history_move ( struct readline_history * history, int offset, const char * old_string )

static

Move to new history depth.

Parameters

history	History buffer
offset	Offset by which to change depth
old_string	String (possibly modified) at current depth

Return values

new_string

String at new depth, or NULL for no movement

Definition at line 151 of file readline.c.

                                                                        {
        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;
}

References readline_history::depth, history_fetch(), history_store(), NULL, offset, and READLINE_HISTORY_MAX_DEPTH.

Referenced by readline_history().

history_append()

void history_append ( struct readline_history * history, const char * string )

static

Append new history entry.

Parameters

history	History buffer
string	String

Definition at line 178 of file readline.c.

                                                  {
        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;
}

References assert, DBGC, free, history_entry(), readline_history::next, NULL, strdup(), and readline_history_entry::string.

Referenced by readline_history().

history_cleanup()

void history_cleanup ( struct readline_history * history )

static

Clean up history after editing.

Parameters

history

History buffer

Definition at line 207 of file readline.c.

                                                                 {
        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 );
}

References assert, readline_history::depth, readline_history::entries, free, history_entry(), NULL, readline_history_entry::string, and readline_history_entry::temp.

Referenced by readline_history().

history_free()

void history_free

(

struct readline_history *

history

)

Free history buffer.

Parameters

history

History buffer

Definition at line 232 of file readline.c.

                                                       {
        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 );
        }
}

References assert, readline_history::entries, free, NULL, readline_history_entry::string, and readline_history_entry::temp.

Referenced by shell().

readline_history()

int readline_history	(	const char *	prompt,
		const char *	prefill,
		struct readline_history *	history,
		unsigned long	timeout,
		char **	line )

Read line from console (with history)

Parameters

prompt	Prompt string
prefill	Prefill string, or NULL for no prefill
history	History buffer, or NULL for no history
timeout	Timeout period, in ticks (0=indefinite)

Return values

line	Line read from console (excluding terminating newline)
rc	Return status code

The returned line is allocated with malloc(); the caller must eventually call free() to release the storage.

Definition at line 258 of file readline.c.

                                     {
        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;
}

References assert, CR, CTRL_C, done, ECANCELED, edit_string(), error, ETIMEDOUT, free, getkey(), history_append(), history_cleanup(), history_move(), init_editstring(), key, KEY_DOWN, KEY_UP, LF, memset(), NULL, printf(), prompt(), putchar(), rc, replace_string(), string, sync_console(), and timeout().

Referenced by readline(), and shell().

readline()

char * readline

(

const char *

prompt

)

Read line from console.

Parameters

prompt

Prompt string

Return values

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.

Definition at line 350 of file readline.c.

                                       {
        char *line;
 
        readline_history ( prompt, NULL, NULL, 0, &line );
        return line;
}

References NULL, prompt(), and readline_history().