2 * Copyright (C) 2006 Michael Brown <mbrown@fensystems.co.uk>.
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.
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.
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
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.
24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL
);
30 #include <ipxe/console.h>
31 #include <ipxe/keys.h>
32 #include <ipxe/editstring.h>
33 #include <readline/readline.h>
41 #define READLINE_MAX 256
44 * Synchronise console with edited string
46 * @v string Editable string
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
);
54 /* Expand region back to old cursor position if applicable */
55 if ( mod_start
> string
->last_cursor
)
56 mod_start
= string
->last_cursor
;
58 /* Expand region forward to new cursor position if applicable */
59 if ( mod_end
< string
->cursor
)
60 mod_end
= string
->cursor
;
62 /* Backspace to start of region */
63 while ( cursor
> mod_start
) {
68 /* Print modified region */
69 while ( cursor
< mod_end
) {
70 putchar ( ( cursor
>= len
) ?
' ' : string
->buf
[cursor
] );
74 /* Backspace to new cursor position */
75 while ( cursor
> string
->cursor
) {
82 * Locate history entry
84 * @v history History buffer
85 * @v depth Depth within history buffer
86 * @ret entry History entry
88 static struct readline_history_entry
*
89 history_entry ( struct readline_history
*history
, unsigned int depth
) {
92 offset
= ( ( history
->next
- depth
) %
93 ( sizeof ( history
->entries
) /
94 sizeof ( history
->entries
[0] ) ) );
95 return &history
->entries
[offset
];
99 * Read string from history buffer
101 * @v history History buffer
102 * @v depth Depth within history buffer
105 static const char * history_fetch ( struct readline_history
*history
,
106 unsigned int depth
) {
107 struct readline_history_entry
*entry
;
109 /* Return the temporary copy if it exists, otherwise return
110 * the persistent copy.
112 entry
= history_entry ( history
, depth
);
113 return ( entry
->temp ? entry
->temp
: entry
->string
);
117 * Write temporary string copy to history buffer
119 * @v history History buffer
120 * @v depth Depth within history buffer
123 static void history_store ( struct readline_history
*history
,
124 unsigned int depth
, const char *string
) {
125 struct readline_history_entry
*entry
;
128 /* Create temporary copy of string */
129 temp
= strdup ( string
);
131 /* Just discard the string; there's nothing we can do */
132 DBGC ( history
, "READLINE %p could not store string\n",
137 /* Store temporary copy */
138 entry
= history_entry ( history
, depth
);
139 free ( entry
->temp
);
144 * Move to new history depth
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
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
);
157 if ( new_depth
> READLINE_HISTORY_MAX_DEPTH
)
162 /* Store temporary copy of old string at current depth */
163 history_store ( history
, history
->depth
, old_string
);
166 history
->depth
= new_depth
;
168 /* Return new string */
173 * Append new history entry
175 * @v history History buffer
178 static void history_append ( struct readline_history
*history
,
179 const char *string
) {
180 struct readline_history_entry
*entry
;
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",
193 /* Increment history position */
196 /* Prepare empty "next" slot */
197 entry
= history_entry ( history
, 0 );
198 free ( entry
->string
);
199 entry
->string
= NULL
;
203 * Clean up history after editing
205 * @v history History buffer
207 static void history_cleanup ( struct readline_history
*history
) {
208 struct readline_history_entry
*entry
;
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
);
223 entry
= history_entry ( history
, 0 );
224 assert ( entry
->string
== NULL
);
228 * Free history buffer
230 * @v history History buffer
232 void history_free ( struct readline_history
*history
) {
233 struct readline_history_entry
*entry
;
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
);
246 * Read line from console (with history)
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
254 * The returned line is allocated with malloc(); the caller must
255 * eventually call free() to release the storage.
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
;
263 const char *new_string
;
266 /* Avoid returning uninitialised data on error */
269 /* Display prompt, if applicable */
271 printf ( "%s", prompt
);
273 /* Ensure cursor is visible */
274 printf ( "\033[?25h" );
276 /* Initialise editable string */
277 memset ( &string
, 0, sizeof ( string
) );
278 init_editstring ( &string
, buf
, sizeof ( buf
) );
281 /* Prefill string, if applicable */
283 replace_string ( &string
, prefill
);
284 sync_console ( &string
);
288 /* Handle keypress */
289 key
= edit_string ( &string
, getkey ( 0 ) );
290 sync_console ( &string
);
295 *line
= strdup ( buf
);
296 rc
= ( ( *line
) ?
0 : -ENOMEM
);
312 /* Handle history movement, if applicable */
313 if ( move_by
&& history
) {
314 new_string
= history_move ( history
, move_by
, buf
);
316 replace_string ( &string
, new_string
);
317 sync_console ( &string
);
325 if ( *line
&& (*line
)[0] )
326 history_append ( history
, *line
);
327 history_cleanup ( history
);
329 assert ( ( rc
== 0 ) ^ ( *line
== NULL
) );
334 * Read line from console
336 * @v prompt Prompt string
337 * @ret line Line read from console (excluding terminating newline)
339 * The returned line is allocated with malloc(); the caller must
340 * eventually call free() to release the storage.
342 char * readline ( const char *prompt
) {
345 readline_history ( prompt
, NULL
, NULL
, &line
);