/* format line and add it to history list, avoiding duplicates if necessary */
static void
my_add_history(char *line)
{
int lookback, count, here;
char *new_entry, *filtered_line;
filtered_line = pass_through_filter(TAG_HISTORY, line);
switch (history_duplicate_avoidance_policy) {
case KEEP_ALL_DOUBLES:
lookback = 0; break;
case ELIMINATE_SUCCESIVE_DOUBLES:
lookback = 1; break;
case ELIMINATE_ALL_DOUBLES:
lookback = history_length; break;
}
new_entry = filtered_line;
lookback = min(history_length, lookback);
for (count = 0, here = history_length + history_base - 1;
count < lookback ;
count++, here--) {
/* DPRINTF3(DEBUG_READLINE, "strcmping <%s> and <%s> (count = %d)", line, history_get(here)->line ,count); */
if (strncmp(new_entry, history_get(here) -> line, 10000) == 0) {
HIST_ENTRY *entry = remove_history (here - history_base); /* according to the history library doc this should be
remove_history(here) @@@?*/
DPRINTF2(DEBUG_READLINE, "removing duplicate entry #%d (%s)", here, entry->line);
free_foreign(entry->line);
free_foreign(entry);
}
}
add_history(new_entry);
free(new_entry);
}
/* format line and add it to history list, avoiding duplicates if necessary */
static void
my_add_history(char *line)
{
int lookback, count, here;
char *new_entry, *filtered_line;
filtered_line = pass_through_filter(TAG_HISTORY, line);
switch (history_duplicate_avoidance_policy) {
case KEEP_ALL_DOUBLES:
lookback = 0; break;
case ELIMINATE_SUCCESIVE_DOUBLES:
lookback = 1; break;
case ELIMINATE_ALL_DOUBLES:
lookback = history_length; break;
}
new_entry = filtered_line;
lookback = min(history_length, lookback);
for (count = 0, here = history_length - 1;
count < lookback ;
count++, here--) {
DPRINTF4(DEBUG_READLINE, "strcmping <%s> and <%s> (count = %d, here = %d)", line, history_get(history_base + here)->line ,count, here);
if (strncmp(new_entry, history_get(history_base + here) -> line, 10000) == 0) { /* history_get uses the logical offset history_base .. */
HIST_ENTRY *entry = remove_history (here); /* .. but remove_history doesn't! */
DPRINTF2(DEBUG_READLINE, "removing duplicate entry #%d (%s)", here, entry->line);
free_foreign(entry->line);
free_foreign(entry);
}
}
add_history(new_entry);
free(new_entry);
}
static void
line_handler(char *line)
{
char *rewritten_line, *filtered_line;
if (line == NULL) { /* EOF on input, forward it */
DPRINTF1(DEBUG_READLINE, "EOF detected, writing character %d", term_eof);
/* colour_the_prompt = FALSE; don't mess with the cruft that may come out of dying command @@@ but command may not die!*/
write_EOF_to_master_pty();
} else {
if (*line && /* forget empty lines */
redisplay && /* forget passwords */
!forget_line && /* forget lines entered by CTRL-O */
!match_regexp(line, forget_regexp, TRUE)) { /* forget lines (case-inseitively) matching -g option regexp */
my_add_history(line);
}
forget_line = FALSE; /* until CTRL-O is used again */
/* Time for a design decision: when we send the accepted line to the client command, it will most probably be echoed
back. We have two choices: we leave the entered line on screen and suppress just enough of the clients output (I
believe this is what rlfe does), or we remove the entered input (but not the prompt!) and let it be replaced by
the echo.
This is what we do; as a bonus, if the program doesn't echo, e.g. at a password prompt, the **** which has been
put there by our homegrown_redisplay function will be removed (@@@is this what we want?)
I think this method is more natural for multi-line input as well, (we will actually see our multi-line input as
multiple lines) but not everyone will agree with that.
O.K, we know for sure that cursor is at start of line. When clients output arrives, it will be printed at
just the right place - but first we 'll erase the user input (as it may be about to be changed by the filter) */
rl_delete_text(0, rl_end); /* clear line (after prompt) */
rl_point = 0;
my_redisplay(); /* and redisplay (this time without user input, cf the comments for the line_handler() function below) */
rewritten_line =
(multiline_separator ?
search_and_replace(multiline_separator, "\n", line, 0, NULL,
NULL) : mysavestring(line));
if (redisplay)
filtered_line = pass_through_filter(TAG_INPUT, rewritten_line);
else { /* password, none of filters business */
pass_through_filter(TAG_INPUT, "***"); /* filter some input anyway, to keep filter in sync (result is discarded). */
filtered_line = mysavestring(rewritten_line);
}
free(rewritten_line);
/* do we have to adapt clients winzsize now? */
if (deferred_adapt_commands_window_size) {
adapt_tty_winsize(STDIN_FILENO, master_pty_fd);
kill(-command_pid, SIGWINCH);
deferred_adapt_commands_window_size = FALSE;
}
/*OK, now feed line to underlying command and wait for the echo to come back */
put_in_output_queue(filtered_line);
DPRINTF2(DEBUG_READLINE, "putting %d bytes %s in output queue", (int) strlen(rewritten_line),
mangle_string_for_debug_log(rewritten_line, 40));
write_EOL_to_master_pty(return_key ? &return_key : "\n");
accepted_lines++;
free_foreign(line); /* free_foreign because line was malloc'ed by readline, not by rlwrap */
free(filtered_line); /* we're done with them */
return_key = 0;
within_line_edit = FALSE;
if(!RL_ISSTATE(RL_STATE_MACROINPUT)) /* when called during playback of a multi-line macro, line_handler() will be called more
than once whithout re-entering main_loop(). If we'd remove it here, the second call
would crash */
rl_callback_handler_remove();
set_echo(FALSE);
free(saved_rl_state.input_buffer);
free(saved_rl_state.raw_prompt);
free(saved_rl_state.cooked_prompt);
saved_rl_state.input_buffer = mysavestring("");
saved_rl_state.raw_prompt = mysavestring("");
saved_rl_state.cooked_prompt = NULL;
saved_rl_state.point = 0;
saved_rl_state.already_saved = TRUE;
redisplay = TRUE;
if (one_shot_rlwrap)
write_EOF_to_master_pty();
}
}
