/************************************************************************** * text.c -- This file is part of GNU nano. * * * * Copyright (C) 1999-2011, 2013-2018 Free Software Foundation, Inc. * * Copyright (C) 2014-2015 Mark Majeres * * Copyright (C) 2016 Mike Scalora * * Copyright (C) 2016 Sumedh Pendurkar * * Copyright (C) 2018 Marco Diego AurĂ©lio Mesquita * * Copyright (C) 2015-2018 Benno Schulenberg * * * * GNU nano 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 3 of the License, * * or (at your option) any later version. * * * * GNU nano 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, see http://www.gnu.org/licenses/. * * * **************************************************************************/ #include "proto.h" #include #include #include #include #include #ifndef NANO_TINY static pid_t pid_of_command = -1; /* The PID of the forked process -- needed when wanting to abort it. */ #endif #ifdef ENABLE_WRAPPING static bool prepend_wrap = FALSE; /* Should we prepend wrapped text to the next line? */ #endif #ifdef ENABLE_JUSTIFY static filestruct *jusbuffer = NULL; /* The buffer where we store unjustified text. */ static filestruct *jusbottom = NULL; /* A pointer to the end of the buffer with unjustified text. */ #endif #ifdef ENABLE_WORDCOMPLETION static int pletion_x = 0; /* The x position in pletion_line of the last found completion. */ static completion_word *list_of_completions; /* A linked list of the completions that have been attempted. */ #endif #ifndef NANO_TINY /* Toggle the mark. */ void do_mark(void) { if (!openfile->mark) { openfile->mark = openfile->current; openfile->mark_x = openfile->current_x; statusbar(_("Mark Set")); openfile->kind_of_mark = HARDMARK; } else { openfile->mark = NULL; statusbar(_("Mark Unset")); refresh_needed = TRUE; } } #endif /* !NANO_TINY */ #if defined(ENABLE_COLOR) || defined(ENABLE_SPELLER) /* Return an error message containing the given name. */ char *invocation_error(const char *name) { char *message, *invoke_error = _("Error invoking \"%s\""); message = charalloc(strlen(invoke_error) + strlen(name) + 1); sprintf(message, invoke_error, name); return message; } #endif /* Delete the character under the cursor. */ void do_deletion(undo_type action) { #ifndef NANO_TINY size_t old_amount = 0; #endif openfile->placewewant = xplustabs(); if (openfile->current->data[openfile->current_x] != '\0') { /* We're in the middle of a line: delete the current character. */ int char_len = parse_mbchar(openfile->current->data + openfile->current_x, NULL, NULL); size_t line_len = strlen(openfile->current->data + openfile->current_x); #ifndef NANO_TINY /* If the type of action changed or the cursor moved to a different * line, create a new undo item, otherwise update the existing item. */ if (action != openfile->last_action || openfile->current->lineno != openfile->current_undo->lineno) add_undo(action); else update_undo(action); if (ISSET(SOFTWRAP)) old_amount = number_of_chunks_in(openfile->current); #endif /* Move the remainder of the line "in", over the current character. */ charmove(&openfile->current->data[openfile->current_x], &openfile->current->data[openfile->current_x + char_len], line_len - char_len + 1); #ifndef NANO_TINY /* Adjust the mark if it is after the cursor on the current line. */ if (openfile->mark == openfile->current && openfile->mark_x > openfile->current_x) openfile->mark_x -= char_len; #endif /* Adjust the file size. */ openfile->totsize--; } else if (openfile->current != openfile->filebot) { /* We're at the end of a line and not at the end of the file: join * this line with the next. */ filestruct *joining = openfile->current->next; /* If there is a magic line, and we're before it: don't eat it. */ if (joining == openfile->filebot && openfile->current_x != 0 && !ISSET(NO_NEWLINES)) { #ifndef NANO_TINY if (action == BACK) add_undo(BACK); #endif return; } #ifndef NANO_TINY add_undo(action); #endif /* Add the contents of the next line to those of the current one. */ openfile->current->data = charealloc(openfile->current->data, strlen(openfile->current->data) + strlen(joining->data) + 1); strcat(openfile->current->data, joining->data); /* Adjust the file size. */ openfile->totsize--; #ifndef NANO_TINY /* Remember the new file size for a possible redo. */ openfile->current_undo->newsize = openfile->totsize; /* Adjust the mark if it was on the line that was "eaten". */ if (openfile->mark == joining) { openfile->mark = openfile->current; openfile->mark_x += openfile->current_x; } #endif unlink_node(joining); renumber(openfile->current); /* Two lines were joined, so we need to refresh the screen. */ refresh_needed = TRUE; } else /* We're at the end-of-file: nothing to do. */ return; #ifndef NANO_TINY /* If the number of screen rows that a softwrapped line occupies * has changed, we need a full refresh. */ if (ISSET(SOFTWRAP) && refresh_needed == FALSE && number_of_chunks_in(openfile->current) != old_amount) refresh_needed = TRUE; #endif set_modified(); } /* Delete the character under the cursor. */ void do_delete(void) { do_deletion(DEL); } /* Backspace over one character. That is, move the cursor left one * character, and then delete the character under the cursor. */ void do_backspace(void) { if (openfile->current != openfile->fileage || openfile->current_x > 0) { do_left(); do_deletion(BACK); } } #ifndef NANO_TINY /* Delete text from the cursor until the first start of a word to * the right, or to the left when backward is true. */ void do_cutword(bool backward) { /* Remember the current cursor position. */ filestruct *is_current = openfile->current; size_t is_current_x = openfile->current_x; /* Remember where the cutbuffer is and then make it seem blank. */ filestruct *is_cutbuffer = cutbuffer; filestruct *is_cutbottom = cutbottom; cutbuffer = NULL; cutbottom = NULL; /* Move the cursor to a word start, to the left or to the right. * If that word is on another line and the cursor was not already * on the edge of the original line, then put the cursor on that * edge instead, so that lines will not be joined unexpectedly. */ if (backward) { do_prev_word(ISSET(WORD_BOUNDS), FALSE); if (openfile->current != is_current) { if (is_current_x > 0) { openfile->current = is_current; openfile->current_x = 0; } else openfile->current_x = strlen(openfile->current->data); } } else { do_next_word(FALSE, ISSET(WORD_BOUNDS), FALSE); if (openfile->current != is_current && is_current->data[is_current_x] != '\0') { openfile->current = is_current; openfile->current_x = strlen(is_current->data); } } /* Set the mark at the start of that word. */ openfile->mark = openfile->current; openfile->mark_x = openfile->current_x; /* Put the cursor back where it was, so an undo will put it there too. */ openfile->current = is_current; openfile->current_x = is_current_x; /* Now kill the marked region and a word is gone. */ do_cut_text_void(); /* Discard the cut word and restore the cutbuffer. */ free_filestruct(cutbuffer); cutbuffer = is_cutbuffer; cutbottom = is_cutbottom; } /* Delete a word leftward. */ void do_cut_prev_word(void) { do_cutword(TRUE); } /* Delete a word rightward. */ void do_cut_next_word(void) { do_cutword(FALSE); } #endif /* !NANO_TINY */ /* Insert a tab. If the TABS_TO_SPACES flag is set, insert the number * of spaces that a tab would normally take up. */ void do_tab(void) { #ifndef NANO_TINY if (ISSET(TABS_TO_SPACES)) { char *spaces = charalloc(tabsize + 1); size_t length = tabsize - (xplustabs() % tabsize); charset(spaces, ' ', length); spaces[length] = '\0'; do_output(spaces, length, TRUE); free(spaces); } else #endif do_output((char *)"\t", 1, TRUE); } #ifndef NANO_TINY /* Add an indent to the given line. */ void indent_a_line(filestruct *line, char *indentation) { size_t length = strlen(line->data); size_t indent_len = strlen(indentation); /* If the indent is empty, don't change the line. */ if (indent_len == 0) return; /* Add the fabricated indentation to the beginning of the line. */ line->data = charealloc(line->data, length + indent_len + 1); charmove(line->data + indent_len, line->data, length + 1); strncpy(line->data, indentation, indent_len); openfile->totsize += indent_len; /* Compensate for the change in the current line. */ if (line == openfile->mark && openfile->mark_x > 0) openfile->mark_x += indent_len; if (line == openfile->current && openfile->current_x > 0) { openfile->current_x += indent_len; openfile->placewewant = xplustabs(); } } /* Indent the current line (or the marked lines) by tabsize columns. * This inserts either a tab character or a tab's worth of spaces, * depending on whether --tabstospaces is in effect. */ void do_indent(void) { char *indentation; filestruct *top, *bot, *line; /* Use either all the marked lines or just the current line. */ get_range((const filestruct **)&top, (const filestruct **)&bot); /* Skip any leading empty lines. */ while (top != bot->next && top->data[0] == '\0') top = top->next; /* If all lines are empty, there is nothing to do. */ if (top == bot->next) return; indentation = charalloc(tabsize + 1); /* Set the indentation to either a bunch of spaces or a single tab. */ if (ISSET(TABS_TO_SPACES)) { charset(indentation, ' ', tabsize); indentation[tabsize] = '\0'; } else { indentation[0] = '\t'; indentation[1] = '\0'; } add_undo(INDENT); /* Go through each of the lines, adding an indent to the non-empty ones, * and recording whatever was added in the undo item. */ for (line = top; line != bot->next; line = line->next) { char *real_indent = (line->data[0] == '\0') ? "" : indentation; indent_a_line(line, real_indent); update_multiline_undo(line->lineno, real_indent); } free(indentation); set_modified(); refresh_needed = TRUE; shift_held = TRUE; } /* Return the number of bytes of whitespace at the start of the given text, * but at most a tab's worth. */ size_t length_of_white(const char *text) { size_t bytes_of_white = 0; while (TRUE) { if (*text == '\t') return ++bytes_of_white; if (*text != ' ') return bytes_of_white; if (++bytes_of_white == tabsize) return tabsize; text++; } } /* Adjust the positions of mark and cursor when they are on the given line. */ void compensate_leftward(filestruct *line, size_t leftshift) { if (line == openfile->mark) { if (openfile->mark_x < leftshift) openfile->mark_x = 0; else openfile->mark_x -= leftshift; } if (line == openfile->current) { if (openfile->current_x < leftshift) openfile->current_x = 0; else openfile->current_x -= leftshift; openfile->placewewant = xplustabs(); } } /* Remove an indent from the given line. */ void unindent_a_line(filestruct *line, size_t indent_len) { size_t length = strlen(line->data); /* If the indent is empty, don't change the line. */ if (indent_len == 0) return; /* Remove the first tab's worth of whitespace from this line. */ charmove(line->data, line->data + indent_len, length - indent_len + 1); openfile->totsize -= indent_len; /* Adjust the positions of mark and cursor, when they are affected. */ compensate_leftward(line, indent_len); } /* Unindent the current line (or the marked lines) by tabsize columns. * The removed indent can be a mixture of spaces plus at most one tab. */ void do_unindent(void) { filestruct *top, *bot, *line; /* Use either all the marked lines or just the current line. */ get_range((const filestruct **)&top, (const filestruct **)&bot); /* Skip any leading lines that cannot be unindented. */ while (top != bot->next && length_of_white(top->data) == 0) top = top->next; /* If none of the lines can be unindented, there is nothing to do. */ if (top == bot->next) return; add_undo(UNINDENT); /* Go through each of the lines, removing their leading indent where * possible, and saving the removed whitespace in the undo item. */ for (line = top; line != bot->next; line = line->next) { size_t indent_len = length_of_white(line->data); char *indentation = mallocstrncpy(NULL, line->data, indent_len + 1); indentation[indent_len] = '\0'; unindent_a_line(line, indent_len); update_multiline_undo(line->lineno, indentation); free(indentation); } set_modified(); refresh_needed = TRUE; shift_held = TRUE; } /* Perform an undo or redo for an indent or unindent action. */ void handle_indent_action(undo *u, bool undoing, bool add_indent) { undo_group *group = u->grouping; filestruct *line = fsfromline(group->top_line); if (group->next != NULL) statusline(ALERT, "Multiple groups -- please report a bug"); /* When redoing, reposition the cursor and let the indenter adjust it. */ if (!undoing) goto_line_posx(u->lineno, u->begin); /* For each line in the group, add or remove the individual indent. */ while (line && line->lineno <= group->bottom_line) { char *blanks = group->indentations[line->lineno - group->top_line]; if (undoing ^ add_indent) indent_a_line(line, blanks); else unindent_a_line(line, strlen(blanks)); line = line->next; } /* When undoing, reposition the cursor to the recorded location. */ if (undoing) goto_line_posx(u->lineno, u->begin); refresh_needed = TRUE; } #endif /* !NANO_TINY */ /* Test whether the string is empty or consists of only blanks. */ bool white_string(const char *s) { while (*s != '\0' && (is_blank_mbchar(s) || *s == '\r')) s += move_mbright(s, 0); return !*s; } #ifdef ENABLE_COMMENT /* Test whether the given line can be uncommented, or add or remove a comment, * depending on action. Return TRUE if the line is uncommentable, or when * anything was added or removed; FALSE otherwise. */ bool comment_line(undo_type action, filestruct *line, const char *comment_seq) { size_t comment_seq_len = strlen(comment_seq); const char *post_seq = strchr(comment_seq, '|'); /* The postfix, if this is a bracketing type comment sequence. */ size_t pre_len = post_seq ? post_seq++ - comment_seq : comment_seq_len; /* Length of prefix. */ size_t post_len = post_seq ? comment_seq_len - pre_len - 1 : 0; /* Length of postfix. */ size_t line_len = strlen(line->data); if (!ISSET(NO_NEWLINES) && line == openfile->filebot) return FALSE; if (action == COMMENT) { /* Make room for the comment sequence(s), move the text right and * copy them in. */ line->data = charealloc(line->data, line_len + pre_len + post_len + 1); charmove(line->data + pre_len, line->data, line_len + 1); charmove(line->data, comment_seq, pre_len); if (post_len > 0) charmove(line->data + pre_len + line_len, post_seq, post_len + 1); openfile->totsize += pre_len + post_len; /* If needed, adjust the position of the mark and of the cursor. */ if (line == openfile->mark && openfile->mark_x > 0) openfile->mark_x += pre_len; if (line == openfile->current && openfile->current_x > 0) { openfile->current_x += pre_len; openfile->placewewant = xplustabs(); } return TRUE; } /* If the line is commented, report it as uncommentable, or uncomment it. */ if (strncmp(line->data, comment_seq, pre_len) == 0 && (post_len == 0 || strcmp(line->data + line_len - post_len, post_seq) == 0)) { if (action == PREFLIGHT) return TRUE; /* Erase the comment prefix by moving the non-comment part. */ charmove(line->data, line->data + pre_len, line_len - pre_len); /* Truncate the postfix if there was one. */ line->data[line_len - pre_len - post_len] = '\0'; openfile->totsize -= pre_len + post_len; /* Adjust the positions of mark and cursor, when needed. */ compensate_leftward(line, pre_len); return TRUE; } return FALSE; } /* Comment or uncomment the current line or the marked lines. */ void do_comment(void) { const char *comment_seq = GENERAL_COMMENT_CHARACTER; undo_type action = UNCOMMENT; filestruct *top, *bot, *line; bool empty, all_empty = TRUE; #ifdef ENABLE_COLOR if (openfile->syntax) comment_seq = openfile->syntax->comment; if (*comment_seq == '\0') { statusbar(_("Commenting is not supported for this file type")); return; } #endif /* Determine which lines to work on. */ get_range((const filestruct **)&top, (const filestruct **)&bot); /* If only the magic line is selected, don't do anything. */ if (top == bot && bot == openfile->filebot && !ISSET(NO_NEWLINES)) { statusbar(_("Cannot comment past end of file")); return; } /* Figure out whether to comment or uncomment the selected line or lines. */ for (line = top; line != bot->next; line = line->next) { empty = white_string(line->data); /* If this line is not blank and not commented, we comment all. */ if (!empty && !comment_line(PREFLIGHT, line, comment_seq)) { action = COMMENT; break; } all_empty = all_empty && empty; } /* If all selected lines are blank, we comment them. */ action = all_empty ? COMMENT : action; add_undo(action); /* Store the comment sequence used for the operation, because it could * change when the file name changes; we need to know what it was. */ openfile->current_undo->strdata = mallocstrcpy(NULL, comment_seq); /* Comment/uncomment each of the selected lines when possible, and * store undo data when a line changed. */ for (line = top; line != bot->next; line = line->next) { if (comment_line(action, line, comment_seq)) update_multiline_undo(line->lineno, ""); } set_modified(); refresh_needed = TRUE; shift_held = TRUE; } /* Perform an undo or redo for a comment or uncomment action. */ void handle_comment_action(undo *u, bool undoing, bool add_comment) { undo_group *group = u->grouping; /* When redoing, reposition the cursor and let the commenter adjust it. */ if (!undoing) goto_line_posx(u->lineno, u->begin); while (group) { filestruct *f = fsfromline(group->top_line); while (f && f->lineno <= group->bottom_line) { comment_line(undoing ^ add_comment ? COMMENT : UNCOMMENT, f, u->strdata); f = f->next; } group = group->next; } /* When undoing, reposition the cursor to the recorded location. */ if (undoing) goto_line_posx(u->lineno, u->begin); refresh_needed = TRUE; } #endif /* ENABLE_COMMENT */ #ifndef NANO_TINY #define redo_paste undo_cut #define undo_paste redo_cut /* Undo a cut, or redo an uncut. */ void undo_cut(undo *u) { /* Get to where we need to uncut from. */ if (u->xflags == WAS_WHOLE_LINE) goto_line_posx(u->mark_begin_lineno, 0); else goto_line_posx(u->mark_begin_lineno, u->mark_begin_x); /* If nothing was actually cut, positioning the cursor was enough. */ if (!u->cutbuffer) return; copy_from_buffer(u->cutbuffer); if (u->xflags != WAS_MARKED_FORWARD && u->type != PASTE) goto_line_posx(u->mark_begin_lineno, u->mark_begin_x); } /* Redo a cut, or undo an uncut. */ void redo_cut(undo *u) { filestruct *oldcutbuffer = cutbuffer, *oldcutbottom = cutbottom; goto_line_posx(u->lineno, u->begin); /* If nothing was actually cut, positioning the cursor was enough. */ if (!u->cutbuffer) return; cutbuffer = NULL; cutbottom = NULL; openfile->mark = fsfromline(u->mark_begin_lineno); openfile->mark_x = (u->xflags == WAS_WHOLE_LINE) ? 0 : u->mark_begin_x; do_cut_text(FALSE, TRUE, FALSE); free_filestruct(cutbuffer); cutbuffer = oldcutbuffer; cutbottom = oldcutbottom; } /* Undo the last thing(s) we did. */ void do_undo(void) { undo *u = openfile->current_undo; filestruct *f = NULL, *t = NULL; filestruct *oldcutbuffer, *oldcutbottom; char *data, *undidmsg = NULL; size_t from_x, to_x; if (!u) { statusbar(_("Nothing in undo buffer!")); return; } if (u->type <= REPLACE) { f = fsfromline(u->mark_begin_lineno); if (f == NULL) return; } openfile->current_x = u->begin; switch (u->type) { case ADD: /* TRANSLATORS: The next thirteen strings describe actions * that are undone or redone. They are all nouns, not verbs. */ undidmsg = _("text add"); if (u->xflags == WAS_FINAL_LINE && !ISSET(NO_NEWLINES)) remove_magicline(); data = charalloc(strlen(f->data) - strlen(u->strdata) + 1); strncpy(data, f->data, u->begin); strcpy(&data[u->begin], &f->data[u->begin + strlen(u->strdata)]); free(f->data); f->data = data; goto_line_posx(u->lineno, u->begin); break; case ENTER: if (f->next == NULL) { statusline(ALERT, "Missing break line -- please report a bug"); break; } undidmsg = _("line break"); from_x = (u->begin == 0) ? 0 : u->mark_begin_x; to_x = (u->begin == 0) ? u->mark_begin_x : u->begin; f->data = charealloc(f->data, strlen(f->data) + strlen(&u->strdata[from_x]) + 1); strcat(f->data, &u->strdata[from_x]); unlink_node(f->next); renumber(f); goto_line_posx(u->lineno, to_x); break; case BACK: case DEL: undidmsg = _("text delete"); data = charalloc(strlen(f->data) + strlen(u->strdata) + 1); strncpy(data, f->data, u->begin); strcpy(&data[u->begin], u->strdata); strcpy(&data[u->begin + strlen(u->strdata)], &f->data[u->begin]); free(f->data); f->data = data; goto_line_posx(u->mark_begin_lineno, u->mark_begin_x); break; case JOIN: undidmsg = _("line join"); /* When the join was done by a Backspace at the tail of the file, * and the nonewlines flag isn't set, do not re-add a newline that * wasn't actually deleted; just position the cursor. */ if (u->xflags == WAS_FINAL_BACKSPACE && !ISSET(NO_NEWLINES)) { goto_line_posx(openfile->filebot->lineno, 0); break; } t = make_new_node(f); t->data = mallocstrcpy(NULL, u->strdata); data = mallocstrncpy(NULL, f->data, u->mark_begin_x + 1); data[u->mark_begin_x] = '\0'; free(f->data); f->data = data; splice_node(f, t); renumber(t); goto_line_posx(u->lineno, u->begin); break; case REPLACE: undidmsg = _("text replace"); goto_line_posx(u->lineno, u->begin); data = u->strdata; u->strdata = f->data; f->data = data; break; #ifdef ENABLE_WRAPPING case SPLIT_END: goto_line_posx(u->lineno, u->begin); openfile->current_undo = openfile->current_undo->next; while (openfile->current_undo->type != SPLIT_BEGIN) do_undo(); u = openfile->current_undo; case SPLIT_BEGIN: undidmsg = _("text add"); break; #endif case CUT_TO_EOF: case CUT: undidmsg = _("text cut"); undo_cut(u); break; case PASTE: undidmsg = _("text uncut"); undo_paste(u); break; case INSERT: undidmsg = _("text insert"); oldcutbuffer = cutbuffer; oldcutbottom = cutbottom; cutbuffer = NULL; cutbottom = NULL; openfile->mark = fsfromline(u->mark_begin_lineno); openfile->mark_x = u->mark_begin_x; goto_line_posx(u->lineno, u->begin); cut_marked(NULL); free_filestruct(u->cutbuffer); u->cutbuffer = cutbuffer; u->cutbottom = cutbottom; cutbuffer = oldcutbuffer; cutbottom = oldcutbottom; break; case COUPLE_BEGIN: undidmsg = u->strdata; goto_line_posx(u->lineno, u->begin); break; case COUPLE_END: openfile->current_undo = openfile->current_undo->next; do_undo(); do_undo(); do_undo(); return; case INDENT: handle_indent_action(u, TRUE, TRUE); undidmsg = _("indent"); break; case UNINDENT: handle_indent_action(u, TRUE, FALSE); undidmsg = _("unindent"); break; #ifdef ENABLE_COMMENT case COMMENT: handle_comment_action(u, TRUE, TRUE); undidmsg = _("comment"); break; case UNCOMMENT: handle_comment_action(u, TRUE, FALSE); undidmsg = _("uncomment"); break; #endif default: statusline(ALERT, "Wrong undo type -- please report a bug"); break; } if (undidmsg && !pletion_line) statusline(HUSH, _("Undid action (%s)"), undidmsg); openfile->current_undo = openfile->current_undo->next; openfile->last_action = OTHER; openfile->mark = NULL; openfile->placewewant = xplustabs(); openfile->totsize = u->wassize; /* When at the point where the file was last saved, unset "Modified". */ if (openfile->current_undo == openfile->last_saved) { openfile->modified = FALSE; titlebar(NULL); } else set_modified(); } /* Redo the last thing(s) we undid. */ void do_redo(void) { filestruct *f = NULL, *shoveline; char *data, *redidmsg = NULL; undo *u = openfile->undotop; if (u == NULL || u == openfile->current_undo) { statusbar(_("Nothing to re-do!")); return; } /* Get the previous undo item. */ while (u != NULL && u->next != openfile->current_undo) u = u->next; if (u == NULL) { statusline(ALERT, "Bad undo stack -- please report a bug"); return; } if (u->type <= REPLACE) { f = fsfromline(u->mark_begin_lineno); if (f == NULL) return; } switch (u->type) { case ADD: redidmsg = _("text add"); if (u->xflags == WAS_FINAL_LINE && !ISSET(NO_NEWLINES)) new_magicline(); data = charalloc(strlen(f->data) + strlen(u->strdata) + 1); strncpy(data, f->data, u->begin); strcpy(&data[u->begin], u->strdata); strcpy(&data[u->begin + strlen(u->strdata)], &f->data[u->begin]); free(f->data); f->data = data; goto_line_posx(u->mark_begin_lineno, u->mark_begin_x); break; case ENTER: redidmsg = _("line break"); shoveline = make_new_node(f); shoveline->data = mallocstrcpy(NULL, u->strdata); data = mallocstrncpy(NULL, f->data, u->begin + 1); data[u->begin] = '\0'; free(f->data); f->data = data; splice_node(f, shoveline); renumber(shoveline); goto_line_posx(u->lineno + 1, u->mark_begin_x); break; case BACK: case DEL: redidmsg = _("text delete"); data = charalloc(strlen(f->data) + strlen(u->strdata) + 1); strncpy(data, f->data, u->begin); strcpy(&data[u->begin], &f->data[u->begin + strlen(u->strdata)]); free(f->data); f->data = data; goto_line_posx(u->lineno, u->begin); break; case JOIN: if (f->next == NULL) { statusline(ALERT, "Missing join line -- please report a bug"); break; } redidmsg = _("line join"); /* When the join was done by a Backspace at the tail of the file, * and the nonewlines flag isn't set, do not join anything, as * nothing was actually deleted; just position the cursor. */ if (u->xflags == WAS_FINAL_BACKSPACE && !ISSET(NO_NEWLINES)) { goto_line_posx(u->mark_begin_lineno, u->mark_begin_x); break; } f->data = charealloc(f->data, strlen(f->data) + strlen(u->strdata) + 1); strcat(f->data, u->strdata); unlink_node(f->next); renumber(f); goto_line_posx(u->mark_begin_lineno, u->mark_begin_x); break; case REPLACE: redidmsg = _("text replace"); data = u->strdata; u->strdata = f->data; f->data = data; goto_line_posx(u->lineno, u->begin); break; #ifdef ENABLE_WRAPPING case SPLIT_BEGIN: goto_line_posx(u->lineno, u->begin); openfile->current_undo = u; while (openfile->current_undo->type != SPLIT_END) do_redo(); u = openfile->current_undo; goto_line_posx(u->lineno, u->begin); case SPLIT_END: redidmsg = _("text add"); break; #endif case CUT_TO_EOF: case CUT: redidmsg = _("text cut"); redo_cut(u); break; case PASTE: redidmsg = _("text uncut"); redo_paste(u); break; case INSERT: redidmsg = _("text insert"); goto_line_posx(u->lineno, u->begin); copy_from_buffer(u->cutbuffer); free_filestruct(u->cutbuffer); u->cutbuffer = NULL; break; case COUPLE_BEGIN: openfile->current_undo = u; do_redo(); do_redo(); do_redo(); return; case COUPLE_END: redidmsg = u->strdata; goto_line_posx(u->lineno, u->begin); break; case INDENT: handle_indent_action(u, FALSE, TRUE); redidmsg = _("indent"); break; case UNINDENT: handle_indent_action(u, FALSE, FALSE); redidmsg = _("unindent"); break; #ifdef ENABLE_COMMENT case COMMENT: handle_comment_action(u, FALSE, TRUE); redidmsg = _("comment"); break; case UNCOMMENT: handle_comment_action(u, FALSE, FALSE); redidmsg = _("uncomment"); break; #endif default: statusline(ALERT, "Wrong redo type -- please report a bug"); break; } if (redidmsg) statusline(HUSH, _("Redid action (%s)"), redidmsg); openfile->current_undo = u; openfile->last_action = OTHER; openfile->mark = NULL; openfile->placewewant = xplustabs(); openfile->totsize = u->newsize; /* When at the point where the file was last saved, unset "Modified". */ if (openfile->current_undo == openfile->last_saved) { openfile->modified = FALSE; titlebar(NULL); } else set_modified(); } #endif /* !NANO_TINY */ /* Break the current line at the cursor position. */ void do_enter(void) { filestruct *newnode = make_new_node(openfile->current); size_t extra = 0; #ifndef NANO_TINY filestruct *sampleline = openfile->current; bool allblanks = FALSE; if (ISSET(AUTOINDENT)) { #ifdef ENABLE_JUSTIFY /* When doing automatic long-line wrapping and the next line is * in this same paragraph, use its indentation as the model. */ if (!ISSET(NO_WRAP) && sampleline->next != NULL && inpar(sampleline->next) && !begpar(sampleline->next, 0)) sampleline = sampleline->next; #endif extra = indent_length(sampleline->data); /* When breaking in the indentation, limit the automatic one. */ if (extra > openfile->current_x) extra = openfile->current_x; else if (extra == openfile->current_x) allblanks = TRUE; } #endif /* NANO_TINY */ newnode->data = charalloc(strlen(openfile->current->data + openfile->current_x) + extra + 1); strcpy(&newnode->data[extra], openfile->current->data + openfile->current_x); #ifndef NANO_TINY if (ISSET(AUTOINDENT)) { /* Copy the whitespace from the sample line to the new one. */ strncpy(newnode->data, sampleline->data, extra); /* If there were only blanks before the cursor, trim them. */ if (allblanks) openfile->current_x = 0; } #endif null_at(&openfile->current->data, openfile->current_x); #ifndef NANO_TINY add_undo(ENTER); /* Adjust the mark if it was on the current line after the cursor. */ if (openfile->mark == openfile->current && openfile->mark_x > openfile->current_x) { openfile->mark = newnode; openfile->mark_x += extra - openfile->current_x; } #endif /* Insert the newly created line after the current one and renumber. */ splice_node(openfile->current, newnode); renumber(newnode); /* Put the cursor on the new line, after any automatic whitespace. */ openfile->current = newnode; openfile->current_x = extra; openfile->placewewant = xplustabs(); openfile->totsize++; set_modified(); #ifndef NANO_TINY if (ISSET(AUTOINDENT) && !allblanks) openfile->totsize += extra; update_undo(ENTER); #endif refresh_needed = TRUE; focusing = FALSE; } #ifndef NANO_TINY /* Send an unconditional kill signal to the running external command. */ RETSIGTYPE cancel_the_command(int signal) { kill(pid_of_command, SIGKILL); } /* Send the text that starts at the given line to file descriptor fd. */ void send_data(const filestruct *line, int fd) { FILE *tube = fdopen(fd, "w"); if (tube == NULL) return; /* Send each line, except a final empty line. */ while (line != NULL && (line->next != NULL || line->data[0] != '\0')) { fprintf(tube, "%s%s", line->data, line->next == NULL ? "" : "\n"); line = line->next; } fclose(tube); } /* Execute the given command in a shell. Return TRUE on success. */ bool execute_command(const char *command) { int from_fd[2], to_fd[2]; /* The pipes through which text will written and read. */ const bool should_pipe = (command[0] == '|'); FILE *stream; const char *shellenv; struct sigaction oldaction, newaction; /* Original and temporary handlers for SIGINT. */ bool setup_failed = FALSE; /* Whether setting up the temporary SIGINT handler failed. */ /* Create a pipe to read the command's output from, and, if needed, * a pipe to feed the command's input through. */ if (pipe(from_fd) == -1 || (should_pipe && pipe(to_fd) == -1)) { statusbar(_("Could not create pipe")); return FALSE; } /* Check which shell to use. If none is specified, use /bin/sh. */ shellenv = getenv("SHELL"); if (shellenv == NULL) shellenv = (char *) "/bin/sh"; /* Fork a child process to run the command in. */ if ((pid_of_command = fork()) == 0) { /* Child: close the unused read end of the output pipe. */ close(from_fd[0]); /* Connect the write end of the output pipe to the process' output streams. */ dup2(from_fd[1], fileno(stdout)); dup2(from_fd[1], fileno(stderr)); /* If the parent sends text, connect the read end of the * feeding pipe to the child's input stream. */ if (should_pipe) { dup2(to_fd[0], fileno(stdin)); close(to_fd[1]); } /* Run the given command inside the preferred shell. */ execl(shellenv, tail(shellenv), "-c", should_pipe ? &command[1] : command, NULL); /* If the exec call returns, there was an error. */ exit(1); } /* Parent: close the unused write end of the pipe. */ close(from_fd[1]); if (pid_of_command == -1) { statusbar(_("Could not fork")); close(from_fd[0]); return FALSE; } /* If the command starts with "|", pipe buffer or region to the command. */ if (should_pipe) { filestruct *was_cutbuffer = cutbuffer; cutbuffer = NULL; #ifdef ENABLE_MULTIBUFFER if (ISSET(MULTIBUFFER)) { switch_to_prev_buffer(); if (openfile->mark) do_cut_text(TRUE, TRUE, FALSE); } else #endif { add_undo(COUPLE_BEGIN); openfile->undotop->strdata = mallocstrcpy(NULL, _("filtering")); if (openfile->mark == NULL) { openfile->current = openfile->fileage; openfile->current_x = 0; } add_undo(CUT); do_cut_text(FALSE, openfile->mark, openfile->mark == NULL); update_undo(CUT); } if (fork() == 0) { close(to_fd[0]); send_data(cutbuffer != NULL ? cutbuffer : openfile->fileage, to_fd[1]); close(to_fd[1]); exit(0); } close(to_fd[0]); close(to_fd[1]); #ifdef ENABLE_MULTIBUFFER if (ISSET(MULTIBUFFER)) switch_to_next_buffer(); #endif free_filestruct(cutbuffer); cutbuffer = was_cutbuffer; } /* Re-enable interpretation of the special control keys so that we get * SIGINT when Ctrl-C is pressed. */ enable_signals(); /* Set things up so that Ctrl-C will terminate the forked process. */ if (sigaction(SIGINT, NULL, &newaction) == -1) { setup_failed = TRUE; nperror("sigaction"); } else { newaction.sa_handler = cancel_the_command; if (sigaction(SIGINT, &newaction, &oldaction) == -1) { setup_failed = TRUE; nperror("sigaction"); } } stream = fdopen(from_fd[0], "rb"); if (stream == NULL) statusline(ALERT, _("Failed to open pipe: %s"), strerror(errno)); else read_file(stream, 0, "pipe", TRUE); if (should_pipe && !ISSET(MULTIBUFFER)) { add_undo(COUPLE_END); openfile->undotop->strdata = mallocstrcpy(NULL, _("filtering")); } /* Wait for the external command (and possibly data sender) to terminate. */ if (wait(NULL) == -1) nperror("wait"); if (should_pipe && (wait(NULL) == -1)) nperror("wait"); /* If it was changed, restore the handler for SIGINT. */ if (!setup_failed && sigaction(SIGINT, &oldaction, NULL) == -1) nperror("sigaction"); /* Restore the terminal to its desired state, and disable * interpretation of the special control keys again. */ terminal_init(); return TRUE; } /* Discard undo items that are newer than the given one, or all if NULL. * When keep is TRUE, do not touch the last_saved pointer. */ void discard_until(const undo *thisitem, openfilestruct *thefile, bool keep) { undo *dropit = thefile->undotop; undo_group *group; while (dropit != NULL && dropit != thisitem) { thefile->undotop = dropit->next; free(dropit->strdata); free_filestruct(dropit->cutbuffer); group = dropit->grouping; while (group != NULL) { undo_group *next = group->next; free_chararray(group->indentations, group->bottom_line - group->top_line); free(group); group = next; } free(dropit); dropit = thefile->undotop; } /* Adjust the pointer to the top of the undo stack. */ thefile->current_undo = (undo *)thisitem; /* Prevent a chain of editing actions from continuing. */ thefile->last_action = OTHER; /* When requested, record that the undo stack was chopped, and * that thus there is no point at which the file was last saved. */ if (!keep) thefile->last_saved = (undo *)0xbeeb; } /* Add a new undo item of the given type to the top of the current pile. */ void add_undo(undo_type action) { undo *u = openfile->current_undo; /* The thing we did previously. */ /* Blow away newer undo items if we add somewhere in the middle. */ discard_until(u, openfile, TRUE); /* Allocate and initialize a new undo item. */ u = (undo *) nmalloc(sizeof(undo)); u->type = action; u->strdata = NULL; u->cutbuffer = NULL; u->cutbottom = NULL; u->lineno = openfile->current->lineno; u->begin = openfile->current_x; u->mark_begin_lineno = openfile->current->lineno; u->mark_begin_x = openfile->current_x; u->wassize = openfile->totsize; u->newsize = openfile->totsize; u->xflags = 0; u->grouping = NULL; #ifdef ENABLE_WRAPPING /* If some action caused automatic long-line wrapping, insert the * SPLIT_BEGIN item underneath that action's undo item. Otherwise, * just add the new item to the top of the undo stack. */ if (u->type == SPLIT_BEGIN) { u->next = openfile->undotop->next; openfile->undotop->next = u; } else #endif { u->next = openfile->undotop; openfile->undotop = u; openfile->current_undo = u; } /* Record the info needed to be able to undo each possible action. */ switch (u->type) { case ADD: /* If a new magic line will be added, an undo should remove it. */ if (openfile->current == openfile->filebot) u->xflags = WAS_FINAL_LINE; u->wassize--; break; case ENTER: break; case BACK: /* If the next line is the magic line, don't ever undo this * backspace, as it won't actually have deleted anything. */ if (openfile->current->next == openfile->filebot && openfile->current->data[0] != '\0') u->xflags = WAS_FINAL_BACKSPACE; case DEL: /* When not at the end of a line, store the deleted character, * else purposely fall into the line-joining code. */ if (openfile->current->data[openfile->current_x] != '\0') { char *char_buf = charalloc(MAXCHARLEN + 1); int char_len = parse_mbchar(&openfile->current->data[u->begin], char_buf, NULL); char_buf[char_len] = '\0'; u->strdata = char_buf; if (u->type == BACK) u->mark_begin_x += char_len; break; } case JOIN: if (openfile->current->next) { if (u->type == BACK) { u->lineno = openfile->current->next->lineno; u->begin = 0; } u->strdata = mallocstrcpy(NULL, openfile->current->next->data); } action = u->type = JOIN; break; case REPLACE: u->strdata = mallocstrcpy(NULL, openfile->current->data); break; #ifdef ENABLE_WRAPPING case SPLIT_BEGIN: action = openfile->undotop->type; break; case SPLIT_END: break; #endif case CUT_TO_EOF: break; case CUT: if (openfile->mark) { u->mark_begin_lineno = openfile->mark->lineno; u->mark_begin_x = openfile->mark_x; u->xflags = MARK_WAS_SET; } else if (!ISSET(CUT_FROM_CURSOR)) { /* The entire line is being cut regardless of the cursor position. */ u->begin = 0; u->xflags = WAS_WHOLE_LINE; } break; case PASTE: u->cutbuffer = copy_filestruct(cutbuffer); u->lineno += cutbottom->lineno - cutbuffer->lineno; break; case INSERT: case COUPLE_BEGIN: case COUPLE_END: break; case INDENT: case UNINDENT: break; #ifdef ENABLE_COMMENT case COMMENT: case UNCOMMENT: break; #endif default: statusline(ALERT, "Wrong undo adding type -- please report a bug"); break; } openfile->last_action = action; } /* Update a multiline undo item. This should be called once for each line * affected by a multiple-line-altering feature. The indentation that is * added or removed is saved separately for each line in the undo item. */ void update_multiline_undo(ssize_t lineno, char *indentation) { undo *u = openfile->current_undo; /* If there already is a group and the current line is contiguous with it, * extend the group; otherwise, create a new group. */ if (u->grouping && u->grouping->bottom_line + 1 == lineno) { size_t number_of_lines; u->grouping->bottom_line++; number_of_lines = u->grouping->bottom_line - u->grouping->top_line + 1; u->grouping->indentations = (char **)nrealloc(u->grouping->indentations, number_of_lines * sizeof(char *)); u->grouping->indentations[number_of_lines - 1] = mallocstrcpy(NULL, indentation); } else { undo_group *born = (undo_group *)nmalloc(sizeof(undo_group)); born->next = u->grouping; u->grouping = born; born->top_line = lineno; born->bottom_line = lineno; u->grouping->indentations = (char **)nmalloc(sizeof(char *)); u->grouping->indentations[0] = mallocstrcpy(NULL, indentation); } /* Store the file size after the change, to be used when redoing. */ u->newsize = openfile->totsize; } /* Update an undo item with (among other things) the file size and * cursor position after the given action. */ void update_undo(undo_type action) { undo *u = openfile->undotop; char *char_buf; int char_len; u->newsize = openfile->totsize; switch (u->type) { case ADD: char_buf = charalloc(MAXCHARLEN); char_len = parse_mbchar(&openfile->current->data[u->mark_begin_x], char_buf, NULL); u->strdata = addstrings(u->strdata, u->strdata ? strlen(u->strdata) : 0, char_buf, char_len); u->mark_begin_lineno = openfile->current->lineno; u->mark_begin_x = openfile->current_x; break; case ENTER: u->strdata = mallocstrcpy(NULL, openfile->current->data); u->mark_begin_x = openfile->current_x; break; case BACK: case DEL: char_buf = charalloc(MAXCHARLEN); char_len = parse_mbchar(&openfile->current->data[openfile->current_x], char_buf, NULL); if (openfile->current_x == u->begin) { /* They deleted more: add removed character after earlier stuff. */ u->strdata = addstrings(u->strdata, strlen(u->strdata), char_buf, char_len); u->mark_begin_x = openfile->current_x; } else if (openfile->current_x == u->begin - char_len) { /* They backspaced further: add removed character before earlier. */ u->strdata = addstrings(char_buf, char_len, u->strdata, strlen(u->strdata)); u->begin = openfile->current_x; } else { /* They deleted *elsewhere* on the line: start a new undo item. */ free(char_buf); add_undo(u->type); return; } break; case JOIN: break; case REPLACE: case PASTE: u->lineno = openfile->current->lineno; u->begin = openfile->current_x; break; #ifdef ENABLE_WRAPPING case SPLIT_BEGIN: case SPLIT_END: break; #endif case CUT_TO_EOF: case CUT: if (!cutbuffer) break; free_filestruct(u->cutbuffer); u->cutbuffer = copy_filestruct(cutbuffer); if (u->xflags == MARK_WAS_SET) { /* If the "marking" operation was from right-->left or * bottom-->top, then swap the mark points. */ if ((u->lineno == u->mark_begin_lineno && u->begin < u->mark_begin_x) || u->lineno < u->mark_begin_lineno) { ssize_t line = u->lineno; size_t x_loc = u->begin; u->begin = u->mark_begin_x; u->mark_begin_x = x_loc; u->lineno = u->mark_begin_lineno; u->mark_begin_lineno = line; } else u->xflags = WAS_MARKED_FORWARD; } else { /* Compute the end of the cut for the undo, using our copy. */ u->cutbottom = u->cutbuffer; while (u->cutbottom->next != NULL) u->cutbottom = u->cutbottom->next; u->lineno = u->mark_begin_lineno + u->cutbottom->lineno - u->cutbuffer->lineno; if (ISSET(CUT_FROM_CURSOR) || u->type == CUT_TO_EOF) { u->begin = strlen(u->cutbottom->data); if (u->lineno == u->mark_begin_lineno) u->begin += u->mark_begin_x; } else if (openfile->current == openfile->filebot && ISSET(NO_NEWLINES)) u->begin = strlen(u->cutbottom->data); } break; case INSERT: u->mark_begin_lineno = openfile->current->lineno; u->mark_begin_x = openfile->current_x; case COUPLE_BEGIN: break; case COUPLE_END: u->lineno = openfile->current->lineno; u->begin = openfile->current_x; break; default: statusline(ALERT, "Wrong undo update type -- please report a bug"); break; } } #endif /* !NANO_TINY */ #ifdef ENABLE_WRAPPING /* Unset the prepend_wrap flag. We need to do this as soon as we do * something other than type text. */ void wrap_reset(void) { prepend_wrap = FALSE; } /* Try wrapping the given line. Return TRUE if wrapped, FALSE otherwise. */ bool do_wrap(filestruct *line) { size_t line_len = strlen(line->data); /* The length of the line we wrap. */ ssize_t wrap_loc; /* The index of line->data where we wrap. */ const char *remainder; /* The text after the wrap point. */ size_t rest_length; /* The length of the remainder. */ size_t old_x = openfile->current_x; filestruct *old_line = openfile->current; /* There are three steps. First, we decide where to wrap. Then, we * create the new wrap line. Finally, we clean up. */ /* Step 1, finding where to wrap. We are going to add a new line * after a blank character. In this step, we call break_line() to * get the location of the last blank we can break the line at, and * set wrap_loc to the location of the character after it, so that * the blank is preserved at the end of the line. * * If there is no legal wrap point, or we reach the last character * of the line while trying to find one, we should return without * wrapping. Note that if autoindent is turned on, we don't break * at the end of it! */ /* Find the last blank where we can break the line. */ wrap_loc = break_line(line->data, fill, FALSE); /* If we couldn't break the line, or we've reached the end of it, we * don't wrap. */ if (wrap_loc == -1 || line->data[wrap_loc] == '\0') return FALSE; /* Otherwise, move forward to the character just after the blank. */ wrap_loc += move_mbright(line->data + wrap_loc, 0); /* If we've reached the end of the line, we don't wrap. */ if (line->data[wrap_loc] == '\0') return FALSE; #ifndef NANO_TINY /* If autoindent is turned on, and we're on the character just after * the indentation, we don't wrap. */ if (ISSET(AUTOINDENT) && wrap_loc == indent_length(line->data)) return FALSE; add_undo(SPLIT_BEGIN); #endif openfile->current = line; /* Step 2, making the new wrap line. It will consist of indentation * followed by the text after the wrap point, optionally followed by * a space (if the text after the wrap point doesn't end in a blank) * and the text of the next line, if they can fit without wrapping, * the next line exists, and the prepend_wrap flag is set. */ /* The remainder is the text that will be wrapped to the next line. */ remainder = line->data + wrap_loc; rest_length = line_len - wrap_loc; /* We prepend the wrapped text to the next line, if the prepend_wrap * flag is set, there is a next line, and prepending would not make * the line too long. */ if (prepend_wrap && line != openfile->filebot) { const char *tail = remainder + move_mbleft(remainder, rest_length); /* Go to the end of the line. */ openfile->current_x = line_len; /* If the remainder doesn't end in a blank, add a space. */ if (!is_blank_mbchar(tail)) { #ifndef NANO_TINY add_undo(ADD); #endif line->data = charealloc(line->data, line_len + 2); line->data[line_len] = ' '; line->data[line_len + 1] = '\0'; remainder = line->data + wrap_loc; rest_length++; openfile->totsize++; openfile->current_x++; #ifndef NANO_TINY update_undo(ADD); #endif } if (rest_length + strlen(line->next->data) <= fill) { /* Delete the LF to join the two lines. */ do_delete(); /* Delete any leading blanks from the joined-on line. */ while (is_blank_mbchar(&line->data[openfile->current_x])) do_delete(); } } /* Go to the wrap location. */ openfile->current_x = wrap_loc; /* When requested, snip trailing blanks off the wrapped line. */ if (ISSET(TRIM_BLANKS)) { size_t tail_x = move_mbleft(line->data, wrap_loc); size_t typed_x = move_mbleft(line->data, old_x); while (tail_x != typed_x && is_blank_mbchar(line->data + tail_x)) { openfile->current_x = tail_x; do_delete(); tail_x = move_mbleft(line->data, tail_x); } } /* Now split the line. */ do_enter(); if (old_x < wrap_loc) { openfile->current_x = old_x; openfile->current = old_line; prepend_wrap = TRUE; } else { openfile->current_x += (old_x - wrap_loc); prepend_wrap = FALSE; } openfile->placewewant = xplustabs(); #ifndef NANO_TINY add_undo(SPLIT_END); #endif return TRUE; } #endif /* ENABLE_WRAPPING */ #if defined(ENABLE_HELP) || defined(ENABLED_WRAPORJUSTIFY) /* We are trying to break a chunk off line. We find the last blank such * that the display length to there is at most (goal + 1). If there is * no such blank, then we find the first blank. We then take the last * blank in that group of blanks. The terminating '\0' counts as a * blank, as does a '\n' if snap_at_nl is TRUE. */ ssize_t break_line(const char *line, ssize_t goal, bool snap_at_nl) { ssize_t lastblank = -1; /* The index of the last blank we found. */ ssize_t index = 0; /* The index of the character we are looking at. */ size_t column = 0; /* The column position that corresponds with index. */ int char_len = 0; /* The length of the current character, in bytes. */ /* Find the last blank that does not overshoot the target column. */ while (*line != '\0' && ((ssize_t)column <= goal)) { if (is_blank_mbchar(line) || (snap_at_nl && *line == '\n')) { lastblank = index; if (*line == '\n') break; } char_len = parse_mbchar(line, NULL, &column); line += char_len; index += char_len; } /* If the whole line displays shorter than goal, we're done. */ if ((ssize_t)column <= goal) return index; #ifdef ENABLE_HELP /* If we're wrapping a help text and no blank was found, or was * found only as the first character, force a line break. */ if (snap_at_nl && lastblank < 1) return (index - char_len); #endif /* If no blank was found within the goal width, seek one after it. */ if (lastblank < 0) { while (*line != '\0') { if (is_blank_mbchar(line)) lastblank = index; else if (lastblank > 0) return lastblank; char_len = parse_mbchar(line, NULL, NULL); line += char_len; index += char_len; } return -1; } /* Move the pointer back to the last blank, and then step beyond it. */ line = line - index + lastblank; char_len = parse_mbchar(line, NULL, NULL); line += char_len; /* Skip any consecutive blanks after the last blank. */ while (*line != '\0' && is_blank_mbchar(line)) { lastblank += char_len; char_len = parse_mbchar(line, NULL, NULL); line += char_len; } return lastblank; } #endif /* ENABLE_HELP || ENABLED_WRAPORJUSTIFY */ #if !defined(NANO_TINY) || defined(ENABLE_JUSTIFY) /* The "indentation" of a line is the whitespace between the quote part * and the non-whitespace of the line. */ size_t indent_length(const char *line) { size_t len = 0; char onechar[MAXCHARLEN]; int charlen; while (*line != '\0') { charlen = parse_mbchar(line, onechar, NULL); if (!is_blank_mbchar(onechar)) break; line += charlen; len += charlen; } return len; } #endif /* !NANO_TINY || ENABLE_JUSTIFY */ #ifdef ENABLE_JUSTIFY /* justify_format() replaces blanks with spaces and multiple spaces by 1 * (except it maintains up to 2 after a character in punct optionally * followed by a character in brackets, and removes all from the end). * * justify_format() might make paragraph->data shorter, and change the * actual pointer with null_at(). * * justify_format() will not look at the first skip characters of * paragraph. skip should be at most strlen(paragraph->data). The * character at paragraph[skip + 1] must not be blank. */ void justify_format(filestruct *paragraph, size_t skip) { char *end, *new_end, *new_paragraph_data; size_t shift = 0; #ifndef NANO_TINY size_t mark_shift = 0; #endif end = paragraph->data + skip; new_paragraph_data = charalloc(strlen(paragraph->data) + 1); strncpy(new_paragraph_data, paragraph->data, skip); new_end = new_paragraph_data + skip; while (*end != '\0') { int end_len; /* If this character is blank, change it to a space if * necessary, and skip over all blanks after it. */ if (is_blank_mbchar(end)) { end_len = parse_mbchar(end, NULL, NULL); *new_end = ' '; new_end++; end += end_len; while (*end != '\0' && is_blank_mbchar(end)) { end_len = parse_mbchar(end, NULL, NULL); end += end_len; shift += end_len; #ifndef NANO_TINY /* Keep track of the change in the current line. */ if (openfile->mark == paragraph && openfile->mark_x >= end - paragraph->data) mark_shift += end_len; #endif } /* If this character is punctuation optionally followed by a * bracket and then followed by blanks, change no more than two * of the blanks to spaces if necessary, and skip over all * blanks after them. */ } else if (mbstrchr(punct, end) != NULL) { end_len = parse_mbchar(end, NULL, NULL); while (end_len > 0) { *new_end = *end; new_end++; end++; end_len--; } if (*end != '\0' && mbstrchr(brackets, end) != NULL) { end_len = parse_mbchar(end, NULL, NULL); while (end_len > 0) { *new_end = *end; new_end++; end++; end_len--; } } if (*end != '\0' && is_blank_mbchar(end)) { end_len = parse_mbchar(end, NULL, NULL); *new_end = ' '; new_end++; end += end_len; } if (*end != '\0' && is_blank_mbchar(end)) { end_len = parse_mbchar(end, NULL, NULL); *new_end = ' '; new_end++; end += end_len; } while (*end != '\0' && is_blank_mbchar(end)) { end_len = parse_mbchar(end, NULL, NULL); end += end_len; shift += end_len; #ifndef NANO_TINY /* Keep track of the change in the current line. */ if (openfile->mark == paragraph && openfile->mark_x >= end - paragraph->data) mark_shift += end_len; #endif } /* If this character is neither blank nor punctuation, leave it * unchanged. */ } else { end_len = parse_mbchar(end, NULL, NULL); while (end_len > 0) { *new_end = *end; new_end++; end++; end_len--; } } } *new_end = *end; /* If there are spaces at the end of the line, remove them. */ while (new_end > new_paragraph_data + skip && *(new_end - 1) == ' ') { new_end--; shift++; } if (shift > 0) { openfile->totsize -= shift; null_at(&new_paragraph_data, new_end - new_paragraph_data); free(paragraph->data); paragraph->data = new_paragraph_data; #ifndef NANO_TINY /* Adjust the mark coordinates to compensate for the change in * the current line. */ if (openfile->mark == paragraph) { openfile->mark_x -= mark_shift; if (openfile->mark_x > new_end - new_paragraph_data) openfile->mark_x = new_end - new_paragraph_data; } #endif } else free(new_paragraph_data); } /* The "quote part" of a line is the largest initial substring matching * the quote string. This function returns the length of the quote part * of the given line. */ size_t quote_length(const char *line) { regmatch_t matches; int rc = regexec("ereg, line, 1, &matches, 0); if (rc == REG_NOMATCH || matches.rm_so == (regoff_t)-1) return 0; /* matches.rm_so should be 0, since the quote string should start * with the caret ^. */ return matches.rm_eo; } /* The maximum depth of recursion. This must be an even number. */ #define RECURSION_LIMIT 222 /* Return TRUE when the given line is the beginning of a paragraph (BOP). */ bool begpar(const filestruct *const line, int depth) { size_t quote_len, indent_len, prev_dent_len; /* If this is the very first line of the buffer, it counts as a BOP * even when it contains no text. */ if (line == openfile->fileage) return TRUE; /* If recursion is going too deep, just say it's not a BOP. */ if (depth > RECURSION_LIMIT) return FALSE; quote_len = quote_length(line->data); indent_len = indent_length(line->data + quote_len); /* If this line contains no text, it is not a BOP. */ if (line->data[quote_len + indent_len] == '\0') return FALSE; /* If the quote part of the preceding line differs, this is a BOP. */ if (quote_len != quote_length(line->prev->data) || strncmp(line->data, line->prev->data, quote_len) != 0) return TRUE; prev_dent_len = indent_length(line->prev->data + quote_len); /* If the preceding line contains no text, this is a BOP. */ if (line->prev->data[quote_len + prev_dent_len] == '\0') return TRUE; /* If the indentation of the preceding line equals the indentation * of this line, this is not a BOP. */ if (prev_dent_len == indent_len && strncmp(line->prev->data + quote_len, line->data + quote_len, indent_len) == 0) return FALSE; /* Otherwise, this is a BOP if the preceding line is not. */ return !begpar(line->prev, depth + 1); } /* Return TRUE when the given line is part of a paragraph. */ bool inpar(const filestruct *const line) { size_t quote_len = quote_length(line->data); return (line->data[quote_len + indent_length(line->data + quote_len)] != '\0'); } /* Move the next par_len lines, starting with first_line, into the * justify buffer, leaving copies of those lines in place. Assume that * par_len is greater than zero, and that there are enough lines after * first_line. */ void backup_lines(filestruct *first_line, size_t par_len) { filestruct *top = first_line; /* The top of the paragraph we're backing up. */ filestruct *bot = first_line; /* The bottom of the paragraph we're backing up. */ size_t i; size_t current_x_save = openfile->current_x; ssize_t fl_lineno_save = first_line->lineno; ssize_t edittop_lineno_save = openfile->edittop->lineno; ssize_t current_lineno_save = openfile->current->lineno; #ifndef NANO_TINY bool mark_is_set = (openfile->mark != NULL); ssize_t was_mark_lineno = (mark_is_set ? openfile->mark->lineno : 0); size_t was_mark_x = openfile->mark_x; #endif /* Move bot down par_len lines to the line after the last line of * the paragraph, if there is one. */ for (i = par_len; i > 0 && bot != openfile->filebot; i--) bot = bot->next; /* Move the paragraph from the current buffer to the justify buffer. */ extract_buffer(&jusbuffer, &jusbottom, top, 0, bot, (i == 1 && bot == openfile->filebot) ? strlen(bot->data) : 0); /* Copy the paragraph back to the current buffer. */ copy_from_buffer(jusbuffer); /* Move upward from the last line of the paragraph to the first * line, putting first_line, edittop, current, and mark_begin at the * same lines in the copied paragraph that they had in the original * paragraph. */ if (openfile->current != openfile->fileage) { top = openfile->current->prev; #ifndef NANO_TINY if (mark_is_set && openfile->current->lineno == was_mark_lineno) { openfile->mark = openfile->current; openfile->mark_x = was_mark_x; } #endif } else top = openfile->current; for (i = par_len; i > 0 && top != NULL; i--) { if (top->lineno == fl_lineno_save) first_line = top; if (top->lineno == edittop_lineno_save) openfile->edittop = top; if (top->lineno == current_lineno_save) openfile->current = top; #ifndef NANO_TINY if (mark_is_set && top->lineno == was_mark_lineno) { openfile->mark = top; openfile->mark_x = was_mark_x; } #endif top = top->prev; } /* Put current_x at the same place in the copied paragraph that it * had in the original paragraph. */ openfile->current_x = current_x_save; set_modified(); } /* Find the beginning of the current paragraph if we're in one, or the * beginning of the next paragraph if we're not. Afterwards, save the * quote length and paragraph length in *quote and *par. Return TRUE if * we found a paragraph, and FALSE if there was an error or we didn't * find a paragraph. */ bool find_paragraph(size_t *const quote, size_t *const par) { size_t quote_len; /* Length of the initial quotation of the paragraph we search for. */ size_t par_len; /* Number of lines in the paragraph we search for. */ filestruct *current_save; /* The line at the beginning of the paragraph we search for. */ if (quoterc != 0) { statusline(ALERT, _("Bad quote string %s: %s"), quotestr, quoteerr); return FALSE; } /* If we're at the end of the last line of the file, it means that * there aren't any paragraphs left, so get out. */ if (openfile->current == openfile->filebot && openfile->current_x == strlen(openfile->filebot->data)) return FALSE; /* If the current line isn't in a paragraph, move forward to the * last line of the next paragraph, if any. */ if (!inpar(openfile->current)) { do_para_end(FALSE); /* If we end up past the beginning of the line, it means that * we're at the end of the last line of the file, and the line * isn't blank, in which case the last line of the file is the * last line of the next paragraph. * * Otherwise, if we end up on a line that's in a paragraph, it * means that we're on the line after the last line of the next * paragraph, in which case we should move back to the last line * of the next paragraph. */ if (openfile->current_x == 0) { if (!openfile->current->prev || !inpar(openfile->current->prev)) return FALSE; if (openfile->current != openfile->fileage) openfile->current = openfile->current->prev; } } /* If the current line is in a paragraph and isn't its first line, move * back to the first line of the paragraph. */ if (inpar(openfile->current) && !begpar(openfile->current, 0)) do_para_begin(FALSE); /* Now current is the first line of the paragraph. Set quote_len to * the quotation length of that line, and set par_len to the number * of lines in this paragraph. */ quote_len = quote_length(openfile->current->data); current_save = openfile->current; do_para_end(FALSE); par_len = openfile->current->lineno - current_save->lineno; /* If we end up past the beginning of the line, it means that we're at * the end of the last line of the file, and the line isn't blank, in * which case the last line of the file is part of the paragraph. */ if (openfile->current_x > 0) par_len++; openfile->current = current_save; /* Save the values of quote_len and par_len. */ *quote = quote_len; *par = par_len; return TRUE; } /* Justify the current paragraph, and justify the entire file when * full_justify is TRUE. */ void do_justify(bool full_justify) { size_t quote_len; /* Length of the quote part of the current paragraph. */ size_t par_len; /* Number of lines in the current paragraph. */ filestruct *first_par_line = NULL; /* Will be the first line of the justified paragraph(s), if any. * For restoring after unjustify. */ filestruct *last_par_line = NULL; /* Will be the line after the last line of the justified * paragraph(s), if any. Also for restoring after unjustify. */ bool filebot_inpar = FALSE; /* Whether the text at filebot is part of the current paragraph. */ int kbinput; /* The first keystroke after a justification. */ functionptrtype func; /* The function associated with that keystroke. */ /* We save these variables to be restored if the user unjustifies. */ filestruct *edittop_save = openfile->edittop; size_t firstcolumn_save = openfile->firstcolumn; filestruct *current_save = openfile->current; size_t current_x_save = openfile->current_x; #ifndef NANO_TINY filestruct *was_mark = openfile->mark; size_t was_mark_x = openfile->mark_x; #endif bool modified_save = openfile->modified; /* Move to the beginning of the current line, so that justifying at * the end of the last line of the file, if that line isn't blank, * will work the first time through. */ openfile->current_x = 0; /* If we're justifying the entire file, start at the beginning. */ if (full_justify) openfile->current = openfile->fileage; /* Find the first line of the paragraph(s) to be justified. * If the search failed, it means that there are no paragraph(s) to * justify, so refresh the screen and get out. */ if (!find_paragraph("e_len, &par_len)) { refresh_needed = TRUE; return; } /* Move the original paragraph(s) * to the justify buffer, splice a copy of the original * paragraph(s) into the file in the same place, and set * first_par_line to the first line of the copy. */ { backup_lines(openfile->current, full_justify ? openfile->filebot->lineno - openfile->current->lineno + ((openfile->filebot->data[0] != '\0') ? 1 : 0) : par_len); first_par_line = openfile->current; } while (TRUE) { filestruct *firstline; /* The first line of the current paragraph. */ filestruct *sampleline; /* The line from which the indentation is copied -- either * the first and only or the second line of the paragraph. */ size_t lead_len; /* Length of the quote part plus the indentation part. */ ssize_t break_pos; /* Where we will break lines. */ char *lead_string; /* The quote+indent stuff that is copied from the sample line. */ /* par_len will be one greater than the number of lines between * current and filebot if filebot is the last line in the * paragraph. Set filebot_inpar to TRUE if this is the case. */ filebot_inpar = (openfile->current->lineno + par_len == openfile->filebot->lineno + 1); /* Remember the first line of the current paragraph. */ firstline = openfile->current; /* The sample line is either the only line or the second line. */ sampleline = (par_len == 1 ? firstline : firstline->next); /* Copy the leading part (quoting + indentation) of the sample line. */ lead_len = quote_len + indent_length(sampleline->data + quote_len); lead_string = mallocstrncpy(NULL, sampleline->data, lead_len + 1); lead_string[lead_len] = '\0'; /* Now tack all the lines of the paragraph together, skipping * the quoting and indentation on all lines after the first. */ while (par_len > 1) { filestruct *next_line = openfile->current->next; size_t line_len = strlen(openfile->current->data); size_t next_line_len = strlen(next_line->data); lead_len = quote_len + indent_length(next_line->data + quote_len); /* We're just about to tack the next line onto this one. If * this line isn't empty, make sure it ends in a space. */ if (line_len > 0 && openfile->current->data[line_len - 1] != ' ') { openfile->current->data = charealloc(openfile->current->data, line_len + 2); openfile->current->data[line_len++] = ' '; openfile->current->data[line_len] = '\0'; openfile->totsize++; } openfile->current->data = charealloc(openfile->current->data, line_len + next_line_len - lead_len + 1); strcat(openfile->current->data, next_line->data + lead_len); #ifndef NANO_TINY /* If needed, adjust the coordinates of the mark. */ if (openfile->mark == next_line) { openfile->mark = openfile->current; openfile->mark_x += line_len - lead_len; } #endif /* Don't destroy edittop! */ if (next_line == openfile->edittop) openfile->edittop = openfile->current; unlink_node(next_line); openfile->totsize -= lead_len + 1; par_len--; } /* Call justify_format() on the paragraph, which will remove excess * spaces from it and change all blank characters to spaces. */ justify_format(openfile->current, quote_len + indent_length(openfile->current->data + quote_len)); while (par_len > 0 && strlenpt(openfile->current->data) > fill) { size_t line_len = strlen(openfile->current->data); /* If this line is too long, try to wrap it to the next line * to make it short enough. */ break_pos = break_line(openfile->current->data + lead_len, fill - strnlenpt(openfile->current->data, lead_len), FALSE); /* If we can't break the line, or don't need to, we're done. */ if (break_pos == -1 || break_pos + lead_len == line_len) break; /* Adjust the breaking position for the leading part and * move it beyond the found whitespace character. */ break_pos += lead_len + 1; /* Insert a new line after the current one and allocate it. */ splice_node(openfile->current, make_new_node(openfile->current)); openfile->current->next->data = charalloc(lead_len + 1 + line_len - break_pos); /* Copy the leading part and the text after the breaking point * into the next line. */ strncpy(openfile->current->next->data, lead_string, lead_len); strcpy(openfile->current->next->data + lead_len, openfile->current->data + break_pos); openfile->totsize += lead_len + 1; par_len++; #ifndef NANO_TINY /* If needed, compensate the mark coordinates for the change * in the current line. */ if (openfile->mark == openfile->current && openfile->mark_x > break_pos) { openfile->mark = openfile->current->next; openfile->mark_x -= break_pos - lead_len; } #endif /* When requested, snip all trailing blanks. */ if (ISSET(TRIM_BLANKS)) { while (break_pos > 0 && is_blank_mbchar(&openfile->current->data[break_pos - 1])) { break_pos--; openfile->totsize--; } } /* Break the current line. */ null_at(&openfile->current->data, break_pos); /* Go to the next line. */ openfile->current = openfile->current->next; par_len--; } free(lead_string); /* Go to the next line, if possible. If there is no next line, * move to the end of the current line. */ if (openfile->current != openfile->filebot) openfile->current = openfile->current->next; else openfile->current_x = strlen(openfile->current->data); /* Renumber the now-justified paragraph, since both refreshing the * edit window and finding a paragraph need correct line numbers. */ renumber(firstline); /* We've just finished justifying the paragraph. If we're not * justifying the entire file, break out of the loop. * Otherwise, continue the loop so that we justify all the * paragraphs in the file. */ if (!full_justify) break; /* Find the next line of the paragraph(s) to be justified. * If the search failed, it means that there are no paragraph(s) to * justify, so break out of the loop. */ if (!find_paragraph("e_len, &par_len)) { break; } } /* We are now done justifying the paragraph(s), so clean * up. totsize has been maintained above. * Set last_par_line to the end of the paragraph(s) justified. * If we've justified the entire file and broken out of the loop, * this should be the last line of the file. */ last_par_line = openfile->current; #ifndef NANO_TINY /* Let a justification cancel a soft mark. */ if (openfile->mark && openfile->kind_of_mark == SOFTMARK) openfile->mark = NULL; #endif edit_refresh(); /* Show "Unjustify" in the help lines. */ uncutfunc->desc = unjust_tag; bottombars(MMAIN); #ifndef NANO_TINY kbinput = KEY_WINCH; /* Now wait for the next keystroke. */ while (kbinput == KEY_WINCH) #endif { statusbar(_("Can now UnJustify!")); place_the_cursor(); kbinput = do_input(FALSE); } /* Unset the suppression flag after showing the Unjustify message. */ suppress_cursorpos = FALSE; func = func_from_key(&kbinput); /* If the keystroke was Unjustify or Undo, then undo the justification. */ if (func == do_uncut_text #ifndef NANO_TINY || func == do_undo #endif ) { /* Splice the preserved * unjustified text back into the file, */ { filestruct *trash = NULL, *dummy = NULL; /* Throw away the justified paragraph, and replace it with * the preserved unjustified text. */ extract_buffer(&trash, &dummy, first_par_line, 0, last_par_line, filebot_inpar ? strlen(last_par_line->data) : 0); free_filestruct(trash); ingraft_buffer(jusbuffer); /* Restore the old position and the mark. */ openfile->edittop = edittop_save; openfile->firstcolumn = firstcolumn_save; openfile->current = current_save; openfile->current_x = current_x_save; #ifndef NANO_TINY if (openfile->mark) { openfile->mark = was_mark; openfile->mark_x = was_mark_x; } #endif openfile->modified = modified_save; if (!openfile->modified) titlebar(NULL); refresh_needed = TRUE; } } else { /* Put the keystroke back into the queue. */ unget_kbinput(kbinput, meta_key); /* Set the desired screen column (always zero, except at EOF). */ openfile->placewewant = xplustabs(); #ifndef NANO_TINY /* Throw away the entire undo stack, to prevent a crash when * the user tries to undo something in the justified text. */ discard_until(NULL, openfile, FALSE); #endif /* Blow away the unjustified text. */ free_filestruct(jusbuffer); } /* Mark the buffer for unjustified text as empty. */ jusbuffer = NULL; wipe_statusbar(); /* Show "Uncut" again in the help lines, and force their redrawing. */ uncutfunc->desc = uncut_tag; currmenu = MMOST; } /* Justify the current paragraph. */ void do_justify_void(void) { do_justify(FALSE); } /* Justify the entire file. */ void do_full_justify(void) { do_justify(TRUE); } #endif /* ENABLE_JUSTIFY */ #if defined(ENABLE_SPELLER) || defined (ENABLE_COLOR) /* Set up an argument list for executing the given command. */ void construct_argument_list(char ***arguments, char *command, char *filename) { char *copy_of_command = mallocstrcpy(NULL, command); char *element = strtok(copy_of_command, " "); int count = 2; while (element != NULL) { *arguments = (char **)nrealloc(*arguments, ++count * sizeof(char *)); (*arguments)[count - 3] = element; element = strtok(NULL, " "); } (*arguments)[count - 2] = filename; (*arguments)[count - 1] = NULL; } #endif #ifdef ENABLE_SPELLER /* Let the user edit the misspelled word. Return FALSE if the user cancels. */ bool fix_spello(const char *word) { char *save_search; size_t firstcolumn_save = openfile->firstcolumn; size_t current_x_save = openfile->current_x; filestruct *edittop_save = openfile->edittop; filestruct *current_save = openfile->current; /* Save where we are. */ bool proceed = FALSE; /* The return value of this function. */ bool result; /* The return value of searching for a misspelled word. */ #ifndef NANO_TINY bool right_side_up = FALSE; /* TRUE if (mark_begin, mark_begin_x) is the top of the mark, * FALSE if (current, current_x) is. */ filestruct *top, *bot; size_t top_x, bot_x; #endif /* Save the current search string, then set it to the misspelled word. */ save_search = last_search; last_search = mallocstrcpy(NULL, word); #ifndef NANO_TINY /* If the mark is on, start at the beginning of the marked region. */ if (openfile->mark) { mark_order((const filestruct **)&top, &top_x, (const filestruct **)&bot, &bot_x, &right_side_up); /* If the region is marked normally, swap the end points, so that * (current, current_x) (where searching starts) is at the top. */ if (right_side_up) { openfile->current = top; openfile->current_x = top_x; openfile->mark = bot; openfile->mark_x = bot_x; } } else #endif /* Otherwise, start from the top of the file. */ { openfile->current = openfile->fileage; openfile->current_x = 0; } /* Find the first whole occurrence of word. */ result = findnextstr(word, TRUE, INREGION, NULL, FALSE, NULL, 0); /* If the word isn't found, alert the user; if it is, allow correction. */ if (result == 0) { statusline(ALERT, _("Unfindable word: %s"), word); lastmessage = HUSH; proceed = TRUE; napms(2800); } else if (result == 1) { size_t from_col = xplustabs(); size_t to_col = from_col + strlenpt(word); #ifndef NANO_TINY filestruct *saved_mark = openfile->mark; openfile->mark = NULL; #endif edit_refresh(); spotlight(TRUE, from_col, to_col); /* Let the user supply a correctly spelled alternative. */ proceed = (do_prompt(FALSE, FALSE, MSPELL, word, NULL, edit_refresh, _("Edit a replacement")) != -1); spotlight(FALSE, from_col, to_col); #ifndef NANO_TINY openfile->mark = saved_mark; #endif /* If a replacement was given, go through all occurrences. */ if (proceed && strcmp(word, answer) != 0) { do_replace_loop(word, TRUE, current_save, ¤t_x_save); /* TRANSLATORS: Shown after fixing misspellings in one word. */ statusbar(_("Next word...")); napms(400); } } #ifndef NANO_TINY if (openfile->mark) { /* Restore the (compensated) end points of the marked region. */ if (right_side_up) { openfile->current = openfile->mark; openfile->current_x = openfile->mark_x; openfile->mark = top; openfile->mark_x = top_x; } else { openfile->current = top; openfile->current_x = top_x; } } else #endif { /* Restore the (compensated) cursor position. */ openfile->current = current_save; openfile->current_x = current_x_save; } /* Restore the string that was last searched for. */ free(last_search); last_search = save_search; /* Restore the viewport to where it was. */ openfile->edittop = edittop_save; openfile->firstcolumn = firstcolumn_save; return proceed; } /* Internal (integrated) spell checking using the spell program, * filtered through the sort and uniq programs. Return NULL for normal * termination, and the error string otherwise. */ const char *do_int_speller(const char *tempfile_name) { char *read_buff, *read_buff_ptr, *read_buff_word; size_t pipe_buff_size, read_buff_size, read_buff_read, bytesread; int spell_fd[2], sort_fd[2], uniq_fd[2], tempfile_fd = -1; pid_t pid_spell, pid_sort, pid_uniq; int spell_status, sort_status, uniq_status; /* Create all three pipes up front. */ if (pipe(spell_fd) == -1 || pipe(sort_fd) == -1 || pipe(uniq_fd) == -1) return _("Could not create pipe"); statusbar(_("Creating misspelled word list, please wait...")); /* A new process to run spell in. */ if ((pid_spell = fork()) == 0) { /* Child continues (i.e. future spell process). */ close(spell_fd[0]); /* Replace the standard input with the temp file. */ if ((tempfile_fd = open(tempfile_name, O_RDONLY)) == -1) goto close_pipes_and_exit; if (dup2(tempfile_fd, STDIN_FILENO) != STDIN_FILENO) { close(tempfile_fd); goto close_pipes_and_exit; } close(tempfile_fd); /* Send spell's standard output to the pipe. */ if (dup2(spell_fd[1], STDOUT_FILENO) != STDOUT_FILENO) goto close_pipes_and_exit; close(spell_fd[1]); /* Start the spell program; we are using $PATH. */ execlp("spell", "spell", NULL); /* This should not be reached if spell is found. */ exit(1); } /* Parent continues here. */ close(spell_fd[1]); /* A new process to run sort in. */ if ((pid_sort = fork()) == 0) { /* Child continues (i.e. future sort process). Replace the * standard input with the standard output of the old pipe. */ if (dup2(spell_fd[0], STDIN_FILENO) != STDIN_FILENO) goto close_pipes_and_exit; close(spell_fd[0]); /* Send sort's standard output to the new pipe. */ if (dup2(sort_fd[1], STDOUT_FILENO) != STDOUT_FILENO) goto close_pipes_and_exit; close(sort_fd[1]); /* Start the sort program. Use -f to ignore case. */ execlp("sort", "sort", "-f", NULL); /* This should not be reached if sort is found. */ exit(1); } close(spell_fd[0]); close(sort_fd[1]); /* A new process to run uniq in. */ if ((pid_uniq = fork()) == 0) { /* Child continues (i.e. future uniq process). Replace the * standard input with the standard output of the old pipe. */ if (dup2(sort_fd[0], STDIN_FILENO) != STDIN_FILENO) goto close_pipes_and_exit; close(sort_fd[0]); /* Send uniq's standard output to the new pipe. */ if (dup2(uniq_fd[1], STDOUT_FILENO) != STDOUT_FILENO) goto close_pipes_and_exit; close(uniq_fd[1]); /* Start the uniq program; we are using PATH. */ execlp("uniq", "uniq", NULL); /* This should not be reached if uniq is found. */ exit(1); } close(sort_fd[0]); close(uniq_fd[1]); /* The child process was not forked successfully. */ if (pid_spell < 0 || pid_sort < 0 || pid_uniq < 0) { close(uniq_fd[0]); return _("Could not fork"); } /* Get the system pipe buffer size. */ if ((pipe_buff_size = fpathconf(uniq_fd[0], _PC_PIPE_BUF)) < 1) { close(uniq_fd[0]); return _("Could not get size of pipe buffer"); } /* Read in the returned spelling errors. */ read_buff_read = 0; read_buff_size = pipe_buff_size + 1; read_buff = read_buff_ptr = charalloc(read_buff_size); while ((bytesread = read(uniq_fd[0], read_buff_ptr, pipe_buff_size)) > 0) { read_buff_read += bytesread; read_buff_size += pipe_buff_size; read_buff = read_buff_ptr = charealloc(read_buff, read_buff_size); read_buff_ptr += read_buff_read; } *read_buff_ptr = '\0'; close(uniq_fd[0]); /* Do any replacements case sensitive, forward, and without regexes. */ SET(CASE_SENSITIVE); UNSET(BACKWARDS_SEARCH); UNSET(USE_REGEXP); read_buff_word = read_buff_ptr = read_buff; /* Process each of the misspelled words. */ while (*read_buff_ptr != '\0') { if ((*read_buff_ptr == '\r') || (*read_buff_ptr == '\n')) { *read_buff_ptr = '\0'; if (read_buff_word != read_buff_ptr) { if (!fix_spello(read_buff_word)) { read_buff_word = read_buff_ptr; break; } } read_buff_word = read_buff_ptr + 1; } read_buff_ptr++; } /* Special case: the last word doesn't end with '\r' or '\n'. */ if (read_buff_word != read_buff_ptr) fix_spello(read_buff_word); free(read_buff); tidy_up_after_search(); refresh_needed = TRUE; /* Process the end of the three processes. */ waitpid(pid_spell, &spell_status, 0); waitpid(pid_sort, &sort_status, 0); waitpid(pid_uniq, &uniq_status, 0); if (WIFEXITED(spell_status) == 0 || WEXITSTATUS(spell_status)) return _("Error invoking \"spell\""); if (WIFEXITED(sort_status) == 0 || WEXITSTATUS(sort_status)) return _("Error invoking \"sort -f\""); if (WIFEXITED(uniq_status) == 0 || WEXITSTATUS(uniq_status)) return _("Error invoking \"uniq\""); /* When all went okay. */ return NULL; close_pipes_and_exit: /* Don't leak any handles. */ close(spell_fd[0]); close(spell_fd[1]); close(sort_fd[0]); close(sort_fd[1]); close(uniq_fd[0]); close(uniq_fd[1]); exit(1); } /* External (alternate) spell checking. Return NULL for normal * termination, and the error string otherwise. */ const char *do_alt_speller(char *tempfile_name) { int alt_spell_status; size_t current_x_save = openfile->current_x; size_t pww_save = openfile->placewewant; ssize_t lineno_save = openfile->current->lineno; bool was_at_eol = (openfile->current->data[openfile->current_x] == '\0'); struct stat spellfileinfo; time_t timestamp; pid_t pid_spell; static char **spellargs = NULL; /* Get the timestamp and the size of the temporary file. */ stat(tempfile_name, &spellfileinfo); timestamp = spellfileinfo.st_mtime; /* If the number of bytes to check is zero, get out. */ if (spellfileinfo.st_size == 0) return NULL; /* Exit from curses mode. */ endwin(); construct_argument_list(&spellargs, alt_speller, tempfile_name); /* Fork a child process and run the alternate spell program in it. */ if ((pid_spell = fork()) == 0) { execvp(spellargs[0], spellargs); /* Terminate the child process if no alternate speller is found. */ exit(1); } else if (pid_spell < 0) return _("Could not fork"); /* Wait for the alternate spell checker to finish. */ wait(&alt_spell_status); /* Reenter curses mode. */ doupdate(); /* Restore the terminal to its previous state. */ terminal_init(); if (!WIFEXITED(alt_spell_status) || WEXITSTATUS(alt_spell_status) != 0) return invocation_error(alt_speller); /* Stat the temporary file again. */ stat(tempfile_name, &spellfileinfo); /* Use the spell-checked file only when it changed. */ if (spellfileinfo.st_mtime != timestamp) { #ifndef NANO_TINY /* Replace the marked text (or entire text) with the corrected text. */ if (openfile->mark) { filestruct *top, *bot; size_t top_x, bot_x; bool right_side_up; ssize_t was_mark_lineno = openfile->mark->lineno; mark_order((const filestruct **)&top, &top_x, (const filestruct **)&bot, &bot_x, &right_side_up); replace_marked_buffer(tempfile_name); /* Adjust the end point of the marked region for any change in * length of the region's last line. */ if (right_side_up) current_x_save = openfile->current_x; else openfile->mark_x = openfile->current_x; /* Restore the mark. */ openfile->mark = fsfromline(was_mark_lineno); } else #endif replace_buffer(tempfile_name); /* Go back to the old position. */ goto_line_posx(lineno_save, current_x_save); if (was_at_eol || openfile->current_x > strlen(openfile->current->data)) openfile->current_x = strlen(openfile->current->data); #ifndef NANO_TINY update_undo(COUPLE_END); #endif openfile->placewewant = pww_save; adjust_viewport(STATIONARY); } return NULL; } /* Spell check the current file. If an alternate spell checker is * specified, use it. Otherwise, use the internal spell checker. */ void do_spell(void) { bool status; FILE *temp_file; char *temp; unsigned stash[sizeof(flags) / sizeof(flags[0])]; /* A storage place for the current flag settings. */ const char *result_msg; if (ISSET(RESTRICTED)) { show_restricted_warning(); return; } temp = safe_tempfile(&temp_file); if (temp == NULL) { statusline(ALERT, _("Error writing temp file: %s"), strerror(errno)); return; } /* Save the settings of the global flags. */ memcpy(stash, flags, sizeof(flags)); /* Don't add an extra newline when writing out the (selected) text. */ SET(NO_NEWLINES); #ifndef NANO_TINY if (openfile->mark) status = write_marked_file(temp, temp_file, TRUE, OVERWRITE); else #endif status = write_file(temp, temp_file, TRUE, OVERWRITE, TRUE); if (!status) { statusline(ALERT, _("Error writing temp file: %s"), strerror(errno)); free(temp); return; } blank_bottombars(); result_msg = (alt_speller ? do_alt_speller(temp) : do_int_speller(temp)); unlink(temp); free(temp); /* Restore the settings of the global flags. */ memcpy(flags, stash, sizeof(flags)); /* If the spell-checker printed any error messages onscreen, make * sure that they're cleared off. */ total_refresh(); if (result_msg != NULL) { if (errno == 0) /* Don't display an error message of "Success". */ statusline(ALERT, _("Spell checking failed: %s"), result_msg); else statusline(ALERT, _("Spell checking failed: %s: %s"), result_msg, strerror(errno)); } else statusbar(_("Finished checking spelling")); } #endif /* ENABLE_SPELLER */ #ifdef ENABLE_COLOR /* Run a linting program on the current buffer. Return NULL for normal * termination, and the error string otherwise. */ void do_linter(void) { char *read_buff, *read_buff_ptr, *read_buff_word; size_t pipe_buff_size, read_buff_size, read_buff_read, bytesread; size_t parsesuccess = 0; int lint_status, lint_fd[2]; pid_t pid_lint; static char **lintargs = NULL; lintstruct *lints = NULL, *tmplint = NULL, *curlint = NULL; if (ISSET(RESTRICTED)) { show_restricted_warning(); return; } if (!openfile->syntax || !openfile->syntax->linter) { statusbar(_("No linter defined for this type of file!")); return; } #ifndef NANO_TINY openfile->mark = NULL; #endif edit_refresh(); if (openfile->modified) { int i = do_yesno_prompt(FALSE, _("Save modified buffer before linting?")); if (i == -1) { statusbar(_("Cancelled")); return; } else if (i == 1 && (do_writeout(FALSE, FALSE) != 1)) return; } /* Create a pipe up front. */ if (pipe(lint_fd) == -1) { statusbar(_("Could not create pipe")); return; } blank_bottombars(); currmenu = MLINTER; statusbar(_("Invoking linter, please wait")); construct_argument_list(&lintargs, openfile->syntax->linter, openfile->filename); /* Start a new process to run the linter in. */ if ((pid_lint = fork()) == 0) { /* Child continues here (i.e. the future linting process). */ close(lint_fd[0]); /* Send the linter's standard output + err to the pipe. */ if (dup2(lint_fd[1], STDOUT_FILENO) != STDOUT_FILENO) exit(9); if (dup2(lint_fd[1], STDERR_FILENO) != STDERR_FILENO) exit(9); close(lint_fd[1]); /* Start the linter program; we are using $PATH. */ execvp(lintargs[0], lintargs); /* This is only reached when the linter is not found. */ exit(9); } /* Parent continues here. */ close(lint_fd[1]); /* If the child process was not forked successfully... */ if (pid_lint < 0) { close(lint_fd[0]); statusbar(_("Could not fork")); return; } /* Get the system pipe buffer size. */ if ((pipe_buff_size = fpathconf(lint_fd[0], _PC_PIPE_BUF)) < 1) { close(lint_fd[0]); statusbar(_("Could not get size of pipe buffer")); return; } /* Read in the returned syntax errors. */ read_buff_read = 0; read_buff_size = pipe_buff_size + 1; read_buff = read_buff_ptr = charalloc(read_buff_size); while ((bytesread = read(lint_fd[0], read_buff_ptr, pipe_buff_size)) > 0) { read_buff_read += bytesread; read_buff_size += pipe_buff_size; read_buff = read_buff_ptr = charealloc(read_buff, read_buff_size); read_buff_ptr += read_buff_read; } *read_buff_ptr = '\0'; close(lint_fd[0]); /* Process the linter output. */ read_buff_word = read_buff_ptr = read_buff; while (*read_buff_ptr != '\0') { if ((*read_buff_ptr == '\r') || (*read_buff_ptr == '\n')) { *read_buff_ptr = '\0'; if (read_buff_word != read_buff_ptr) { char *filename = NULL, *linestr = NULL, *maybecol = NULL; char *message = mallocstrcpy(NULL, read_buff_word); /* At the moment we handle the following formats: * * filenameorcategory:line:column:message (e.g. splint) * filenameorcategory:line,column:message (e.g. pylint) * filenameorcategory:line:message (e.g. pyflakes) */ if (strstr(message, ": ") != NULL) { filename = strtok(read_buff_word, ":"); if ((linestr = strtok(NULL, ":")) != NULL) { if ((maybecol = strtok(NULL, ":")) != NULL) { ssize_t tmplineno = 0, tmpcolno = 0; char *tmplinecol; tmplineno = strtol(linestr, NULL, 10); if (tmplineno <= 0) { read_buff_ptr++; free(message); continue; } tmpcolno = strtol(maybecol, NULL, 10); /* Check if the middle field is in comma format. */ if (tmpcolno <= 0) { strtok(linestr, ","); if ((tmplinecol = strtok(NULL, ",")) != NULL) tmpcolno = strtol(tmplinecol, NULL, 10); else tmpcolno = 1; } /* Nice. We have a lint message we can use. */ parsesuccess++; tmplint = curlint; curlint = nmalloc(sizeof(lintstruct)); curlint->next = NULL; curlint->prev = tmplint; if (curlint->prev != NULL) curlint->prev->next = curlint; curlint->msg = mallocstrcpy(NULL, message); curlint->lineno = tmplineno; curlint->colno = tmpcolno; curlint->filename = mallocstrcpy(NULL, filename); if (lints == NULL) lints = curlint; } } } else free(message); } read_buff_word = read_buff_ptr + 1; } read_buff_ptr++; } /* Process the end of the linting process. */ waitpid(pid_lint, &lint_status, 0); if (!WIFEXITED(lint_status) || WEXITSTATUS(lint_status) > 2) { statusbar(invocation_error(openfile->syntax->linter)); return; } free(read_buff); if (parsesuccess == 0) { statusline(HUSH, _("Got 0 parsable lines from command: %s"), openfile->syntax->linter); return; } bottombars(MLINTER); tmplint = NULL; curlint = lints; while (TRUE) { int kbinput; functionptrtype func; struct stat lintfileinfo; if (stat(curlint->filename, &lintfileinfo) != -1 && (openfile->current_stat == NULL || openfile->current_stat->st_ino != lintfileinfo.st_ino)) { #ifdef ENABLE_MULTIBUFFER const openfilestruct *started_at = openfile; openfile = openfile->next; while (openfile != started_at && (openfile->current_stat == NULL || openfile->current_stat->st_ino != lintfileinfo.st_ino)) openfile = openfile->next; if (openfile->current_stat == NULL || openfile->current_stat->st_ino != lintfileinfo.st_ino) { char *msg = charalloc(1024 + strlen(curlint->filename)); int i; sprintf(msg, _("This message is for unopened file %s," " open it in a new buffer?"), curlint->filename); i = do_yesno_prompt(FALSE, msg); free(msg); if (i == -1) { statusbar(_("Cancelled")); goto free_lints_and_return; } else if (i == 1) { open_buffer(curlint->filename, TRUE); } else { #endif char *dontwantfile = mallocstrcpy(NULL, curlint->filename); lintstruct *restlint = NULL; while (curlint != NULL) { if (strcmp(curlint->filename, dontwantfile) == 0) { if (curlint == lints) lints = curlint->next; else curlint->prev->next = curlint->next; if (curlint->next != NULL) curlint->next->prev = curlint->prev; tmplint = curlint; curlint = curlint->next; free(tmplint->msg); free(tmplint->filename); free(tmplint); } else { if (restlint == NULL) restlint = curlint; curlint = curlint->next; } } free(dontwantfile); if (restlint == NULL) { statusbar(_("No more errors in unopened files, cancelling")); napms(2400); break; } else { curlint = restlint; continue; } #ifdef ENABLE_MULTIBUFFER } } #endif } if (tmplint != curlint) { goto_line_posx(curlint->lineno, curlint->colno - 1); titlebar(NULL); adjust_viewport(CENTERING); #ifdef ENABLE_LINENUMBERS confirm_margin(); #endif edit_refresh(); statusbar(curlint->msg); bottombars(MLINTER); } /* Place the cursor to indicate the affected line. */ place_the_cursor(); wnoutrefresh(edit); kbinput = get_kbinput(bottomwin, VISIBLE); #ifndef NANO_TINY if (kbinput == KEY_WINCH) continue; #endif func = func_from_key(&kbinput); tmplint = curlint; if (func == do_cancel) break; else if (func == do_help_void) { tmplint = NULL; do_help_void(); } else if (func == do_page_up || func == do_prev_block) { if (curlint->prev != NULL) curlint = curlint->prev; else statusbar(_("At first message")); } else if (func == do_page_down || func == do_next_block) { if (curlint->next != NULL) curlint = curlint->next; else statusbar(_("At last message")); } } wipe_statusbar(); #ifdef ENABLE_MULTIBUFFER free_lints_and_return: #endif for (curlint = lints; curlint != NULL;) { tmplint = curlint; curlint = curlint->next; free(tmplint->msg); free(tmplint->filename); free(tmplint); } } #endif /* ENABLE_COLOR */ #ifndef NANO_TINY /* Our own version of "wc". Note that its character counts are in * multibyte characters instead of single-byte characters. */ void do_wordlinechar_count(void) { size_t words = 0, chars = 0; ssize_t nlines = 0; size_t current_x_save = openfile->current_x; size_t pww_save = openfile->placewewant; filestruct *current_save = openfile->current; filestruct *was_mark = openfile->mark; filestruct *top, *bot; size_t top_x, bot_x; /* If the mark is on, partition the buffer so that it * contains only the marked text, and turn the mark off. */ if (was_mark) { mark_order((const filestruct **)&top, &top_x, (const filestruct **)&bot, &bot_x, NULL); filepart = partition_filestruct(top, top_x, bot, bot_x); openfile->mark = NULL; } /* Start at the top of the file. */ openfile->current = openfile->fileage; openfile->current_x = 0; openfile->placewewant = 0; /* Keep moving to the next word (counting punctuation characters as * part of a word, as "wc -w" does), without updating the screen, * until we reach the end of the file, incrementing the total word * count whenever we're on a word just before moving. */ while (openfile->current != openfile->filebot || openfile->current->data[openfile->current_x] != '\0') { if (do_next_word(FALSE, TRUE, FALSE)) words++; } /* Get the total line and character counts, as "wc -l" and "wc -c" * do, but get the latter in multibyte characters. */ if (was_mark) { nlines = openfile->filebot->lineno - openfile->fileage->lineno + 1; chars = get_totsize(openfile->fileage, openfile->filebot); /* Unpartition the buffer so that it contains all the text * again, and turn the mark back on. */ unpartition_filestruct(&filepart); openfile->mark = was_mark; } else { nlines = openfile->filebot->lineno; chars = openfile->totsize; } /* Restore where we were. */ openfile->current = current_save; openfile->current_x = current_x_save; openfile->placewewant = pww_save; /* Display the total word, line, and character counts on the statusbar. */ statusline(HUSH, _("%sWords: %zu Lines: %zd Chars: %zu"), was_mark ? _("In Selection: ") : "", words, nlines, chars); } #endif /* !NANO_TINY */ /* Get verbatim input. */ void do_verbatim_input(void) { int *kbinput; size_t kbinput_len, i; char *output; /* TRANSLATORS: This is displayed when the next keystroke will be * inserted verbatim. */ statusbar(_("Verbatim Input")); place_the_cursor(); /* Read in all the verbatim characters. */ kbinput = get_verbatim_kbinput(edit, &kbinput_len); /* Unsuppress cursor-position display or blank the statusbar. */ if (ISSET(CONSTANT_SHOW)) suppress_cursorpos = FALSE; else wipe_statusbar(); /* Display all the verbatim characters at once, not filtering out * control characters. */ output = charalloc(kbinput_len + 1); for (i = 0; i < kbinput_len; i++) output[i] = (char)kbinput[i]; output[i] = '\0'; free(kbinput); do_output(output, kbinput_len, TRUE); free(output); } #ifdef ENABLE_WORDCOMPLETION /* Copy the found completion candidate. */ char *copy_completion(char *check_line, int start) { char *word; int position = start, len_of_word = 0, index = 0; /* Find the length of the word by travelling to its end. */ while (is_word_mbchar(&check_line[position], FALSE)) { int next = move_mbright(check_line, position); len_of_word += next - position; position = next; } word = charalloc(len_of_word + 1); /* Simply copy the word. */ while (index < len_of_word) word[index++] = check_line[start++]; word[index] = '\0'; return word; } /* Look at the fragment the user has typed, then search the current buffer for * the first word that starts with this fragment, and tentatively complete the * fragment. If the user types 'Complete' again, search and paste the next * possible completion. */ void complete_a_word(void) { char *shard, *completion = NULL; size_t start_of_shard, shard_length = 0; size_t i = 0, j = 0; completion_word *some_word; #ifdef ENABLE_WRAPPING bool was_set_wrapping = !ISSET(NO_WRAP); #endif /* If this is a fresh completion attempt... */ if (pletion_line == NULL) { /* Clear the list of words of a previous completion run. */ while (list_of_completions != NULL) { completion_word *dropit = list_of_completions; list_of_completions = list_of_completions->next; free(dropit->word); free(dropit); } /* Prevent a completion from being merged with typed text. */ openfile->last_action = OTHER; /* Initialize the starting point for searching. */ pletion_line = openfile->fileage; pletion_x = 0; /* Wipe the "No further matches" message. */ wipe_statusbar(); } else { /* Remove the attempted completion from the buffer. */ do_undo(); } /* Find the start of the fragment that the user typed. */ start_of_shard = openfile->current_x; while (start_of_shard > 0) { int step_left = move_mbleft(openfile->current->data, start_of_shard); if (!is_word_mbchar(&openfile->current->data[step_left], FALSE)) break; start_of_shard = step_left; } /* If there is no word fragment before the cursor, do nothing. */ if (start_of_shard == openfile->current_x) { statusbar(_("No word fragment")); pletion_line = NULL; return; } shard = charalloc(openfile->current_x - start_of_shard + 1); /* Copy the fragment that has to be searched for. */ while (start_of_shard < openfile->current_x) shard[shard_length++] = openfile->current->data[start_of_shard++]; shard[shard_length] = '\0'; /* Run through all of the lines in the buffer, looking for shard. */ while (pletion_line != NULL) { int threshold = strlen(pletion_line->data) - shard_length - 1; /* The point where we can stop searching for shard. */ /* Traverse the whole line, looking for shard. */ for (i = pletion_x; (int)i < threshold; i++) { /* If the first byte doesn't match, run on. */ if (pletion_line->data[i] != shard[0]) continue; /* Compare the rest of the bytes in shard. */ for (j = 1; j < shard_length; j++) if (pletion_line->data[i + j] != shard[j]) break; /* If not all of the bytes matched, continue searching. */ if (j < shard_length) continue; /* If the found match is not /longer/ than shard, skip it. */ if (!is_word_mbchar(&pletion_line->data[i + j], FALSE)) continue; /* If the match is not a separate word, skip it. */ if (i > 0 && is_word_mbchar(&pletion_line->data[ move_mbleft(pletion_line->data, i)], FALSE)) continue; /* If this match is the shard itself, ignore it. */ if (pletion_line == openfile->current && i == openfile->current_x - shard_length) continue; completion = copy_completion(pletion_line->data, i); /* Look among earlier attempted completions for a duplicate. */ some_word = list_of_completions; while (some_word && strcmp(some_word->word, completion) != 0) some_word = some_word->next; /* If we've already tried this word, skip it. */ if (some_word != NULL) { free(completion); continue; } /* Add the found word to the list of completions. */ some_word = (completion_word *)nmalloc(sizeof(completion_word)); some_word->word = completion; some_word->next = list_of_completions; list_of_completions = some_word; #ifdef ENABLE_WRAPPING /* Temporarily disable wrapping so only one undo item is added. */ SET(NO_WRAP); #endif /* Inject the completion into the buffer. */ do_output(&completion[shard_length], strlen(completion) - shard_length, FALSE); #ifdef ENABLE_WRAPPING /* If needed, reenable wrapping and wrap the current line. */ if (was_set_wrapping) { UNSET(NO_WRAP); do_wrap(openfile->current); } #endif /* Set the position for a possible next search attempt. */ pletion_x = ++i; free(shard); return; } pletion_line = pletion_line->next; pletion_x = 0; } /* The search has reached the end of the file. */ if (list_of_completions != NULL) { statusline(ALERT, _("No further matches")); refresh_needed = TRUE; } else /* TRANSLATORS: Shown when there are zero possible completions. */ statusline(ALERT, _("No matches")); free(shard); } #endif /* ENABLE_WORDCOMPLETION */