diff options
Diffstat (limited to 'src/text.c')
| -rw-r--r-- | src/text.c | 3074 |
1 files changed, 3074 insertions, 0 deletions
diff --git a/src/text.c b/src/text.c new file mode 100644 index 0000000..54da3f0 --- /dev/null +++ b/src/text.c @@ -0,0 +1,3074 @@ +/* $Id: text.c 4520 2010-11-12 06:23:14Z astyanax $ */ +/************************************************************************** + * text.c * + * * + * Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, * + * 2008, 2009 Free Software Foundation, Inc. * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 3, or (at your option) * + * any later version. * + * * + * This program is distributed in the hope that it will be useful, but * + * WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * + * General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA * + * 02110-1301, USA. * + * * + **************************************************************************/ + +#include "proto.h" + +#include <stdio.h> +#include <signal.h> +#include <unistd.h> +#include <string.h> +#include <fcntl.h> +#include <sys/wait.h> +#include <errno.h> + +#ifndef NANO_TINY +static pid_t pid = -1; + /* The PID of the forked process in execute_command(), for use + * with the cancel_command() signal handler. */ +#endif +#ifndef DISABLE_WRAPPING +static bool prepend_wrap = FALSE; + /* Should we prepend wrapped text to the next line? */ +#endif +#ifndef DISABLE_JUSTIFY +static filestruct *jusbottom = NULL; + /* Pointer to the end of the justify buffer. */ +#endif + +#ifndef NANO_TINY +/* Toggle the mark. */ +void do_mark(void) +{ + openfile->mark_set = !openfile->mark_set; + if (openfile->mark_set) { + statusbar(_("Mark Set")); + openfile->mark_begin = openfile->current; + openfile->mark_begin_x = openfile->current_x; + } else { + statusbar(_("Mark Unset")); + openfile->mark_begin = NULL; + openfile->mark_begin_x = 0; + edit_refresh(); + } +} +#endif /* !NANO_TINY */ + +/* Delete the character under the cursor. */ +void do_delete(void) +{ + size_t orig_lenpt = 0; + +#ifndef NANO_TINY + update_undo(DEL); +#endif + + assert(openfile->current != NULL && openfile->current->data != NULL && openfile->current_x <= strlen(openfile->current->data)); + + openfile->placewewant = xplustabs(); + + if (openfile->current->data[openfile->current_x] != '\0') { + int char_buf_len = parse_mbchar(openfile->current->data + + openfile->current_x, NULL, NULL); + size_t line_len = strlen(openfile->current->data + + openfile->current_x); + + assert(openfile->current_x < strlen(openfile->current->data)); + + if (ISSET(SOFTWRAP)) + orig_lenpt = strlenpt(openfile->current->data); + + /* Let's get dangerous. */ + charmove(&openfile->current->data[openfile->current_x], + &openfile->current->data[openfile->current_x + + char_buf_len], line_len - char_buf_len + 1); + + null_at(&openfile->current->data, openfile->current_x + + line_len - char_buf_len); +#ifndef NANO_TINY + if (openfile->mark_set && openfile->mark_begin == + openfile->current && openfile->current_x < + openfile->mark_begin_x) + openfile->mark_begin_x -= char_buf_len; +#endif + openfile->totsize--; + } else if (openfile->current != openfile->filebot) { + filestruct *foo = openfile->current->next; + + assert(openfile->current_x == strlen(openfile->current->data)); + + /* If we're deleting at the end of a line, we need to call + * edit_refresh(). */ + if (openfile->current->data[openfile->current_x] == '\0') + edit_refresh_needed = TRUE; + + openfile->current->data = charealloc(openfile->current->data, + openfile->current_x + strlen(foo->data) + 1); + strcpy(openfile->current->data + openfile->current_x, + foo->data); +#ifndef NANO_TINY + if (openfile->mark_set && openfile->mark_begin == + openfile->current->next) { + openfile->mark_begin = openfile->current; + openfile->mark_begin_x += openfile->current_x; + } +#endif + if (openfile->filebot == foo) + openfile->filebot = openfile->current; + + unlink_node(foo); + delete_node(foo); + renumber(openfile->current); + openfile->totsize--; + + /* If the NO_NEWLINES flag isn't set, and text has been added to + * the magicline as a result of deleting at the end of the line + * before filebot, add a new magicline. */ + if (!ISSET(NO_NEWLINES) && openfile->current == + openfile->filebot && openfile->current->data[0] != '\0') + new_magicline(); + } else + return; + + if (ISSET(SOFTWRAP) && edit_refresh_needed == FALSE) + if (strlenpt(openfile->current->data) / COLS != orig_lenpt / COLS) + edit_refresh_needed = TRUE; + + set_modified(); + + if (edit_refresh_needed == FALSE) + update_line(openfile->current, openfile->current_x); +} + +/* 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_delete(); + } +} + +/* 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 *output; + size_t output_len = 0, new_pww = xplustabs(); + + do { + new_pww++; + output_len++; + } while (new_pww % tabsize != 0); + + output = charalloc(output_len + 1); + + charset(output, ' ', output_len); + output[output_len] = '\0'; + + do_output(output, output_len, TRUE); + + free(output); + } else { +#endif + do_output((char *) "\t", 1, TRUE); +#ifndef NANO_TINY + } +#endif +} + +#ifndef NANO_TINY +/* Indent or unindent the current line (or, if the mark is on, all lines + * covered by the mark) len columns, depending on whether len is + * positive or negative. If the TABS_TO_SPACES flag is set, indent or + * unindent by len spaces. Otherwise, indent or unindent by (len / + * tabsize) tabs and (len % tabsize) spaces. */ +void do_indent(ssize_t cols) +{ + bool indent_changed = FALSE; + /* Whether any indenting or unindenting was done. */ + bool unindent = FALSE; + /* Whether we're unindenting text. */ + char *line_indent = NULL; + /* The text added to each line in order to indent it. */ + size_t line_indent_len = 0; + /* The length of the text added to each line in order to indent + * it. */ + filestruct *top, *bot, *f; + size_t top_x, bot_x; + + assert(openfile->current != NULL && openfile->current->data != NULL); + + /* If cols is zero, get out. */ + if (cols == 0) + return; + + /* If cols is negative, make it positive and set unindent to + * TRUE. */ + if (cols < 0) { + cols = -cols; + unindent = TRUE; + /* Otherwise, we're indenting, in which case the file will always be + * modified, so set indent_changed to TRUE. */ + } else + indent_changed = TRUE; + + /* If the mark is on, use all lines covered by the mark. */ + if (openfile->mark_set) + mark_order((const filestruct **)&top, &top_x, + (const filestruct **)&bot, &bot_x, NULL); + /* Otherwise, use the current line. */ + else { + top = openfile->current; + bot = top; + } + + if (!unindent) { + /* Set up the text we'll be using as indentation. */ + line_indent = charalloc(cols + 1); + + if (ISSET(TABS_TO_SPACES)) { + /* Set the indentation to cols spaces. */ + charset(line_indent, ' ', cols); + line_indent_len = cols; + } else { + /* Set the indentation to (cols / tabsize) tabs and (cols % + * tabsize) spaces. */ + size_t num_tabs = cols / tabsize; + size_t num_spaces = cols % tabsize; + + charset(line_indent, '\t', num_tabs); + charset(line_indent + num_tabs, ' ', num_spaces); + + line_indent_len = num_tabs + num_spaces; + } + + line_indent[line_indent_len] = '\0'; + } + + /* Go through each line of the text. */ + for (f = top; f != bot->next; f = f->next) { + size_t line_len = strlen(f->data); + size_t indent_len = indent_length(f->data); + + if (!unindent) { + /* If we're indenting, add the characters in line_indent to + * the beginning of the non-whitespace text of this line. */ + f->data = charealloc(f->data, line_len + + line_indent_len + 1); + charmove(&f->data[indent_len + line_indent_len], + &f->data[indent_len], line_len - indent_len + 1); + strncpy(f->data + indent_len, line_indent, line_indent_len); + openfile->totsize += line_indent_len; + + /* Keep track of the change in the current line. */ + if (openfile->mark_set && f == openfile->mark_begin && + openfile->mark_begin_x >= indent_len) + openfile->mark_begin_x += line_indent_len; + + if (f == openfile->current && openfile->current_x >= + indent_len) + openfile->current_x += line_indent_len; + + /* If the NO_NEWLINES flag isn't set, and this is the + * magicline, add a new magicline. */ + if (!ISSET(NO_NEWLINES) && f == openfile->filebot) + new_magicline(); + } else { + size_t indent_col = strnlenpt(f->data, indent_len); + /* The length in columns of the indentation on this + * line. */ + + if (cols <= indent_col) { + size_t indent_new = actual_x(f->data, indent_col - + cols); + /* The length of the indentation remaining on + * this line after we unindent. */ + size_t indent_shift = indent_len - indent_new; + /* The change in the indentation on this line + * after we unindent. */ + + /* If we're unindenting, and there's at least cols + * columns' worth of indentation at the beginning of the + * non-whitespace text of this line, remove it. */ + charmove(&f->data[indent_new], &f->data[indent_len], + line_len - indent_shift - indent_new + 1); + null_at(&f->data, line_len - indent_shift + 1); + openfile->totsize -= indent_shift; + + /* Keep track of the change in the current line. */ + if (openfile->mark_set && f == openfile->mark_begin && + openfile->mark_begin_x > indent_new) { + if (openfile->mark_begin_x <= indent_len) + openfile->mark_begin_x = indent_new; + else + openfile->mark_begin_x -= indent_shift; + } + + if (f == openfile->current && openfile->current_x > + indent_new) { + if (openfile->current_x <= indent_len) + openfile->current_x = indent_new; + else + openfile->current_x -= indent_shift; + } + + /* We've unindented, so set indent_changed to TRUE. */ + if (!indent_changed) + indent_changed = TRUE; + } + } + } + + if (!unindent) + /* Clean up. */ + free(line_indent); + + if (indent_changed) { + /* Mark the file as modified. */ + set_modified(); + + /* Update the screen. */ + edit_refresh_needed = TRUE; + } +} + +/* Indent the current line, or all lines covered by the mark if the mark + * is on, tabsize columns. */ +void do_indent_void(void) +{ + do_indent(tabsize); +} + +/* Unindent the current line, or all lines covered by the mark if the + * mark is on, tabsize columns. */ +void do_unindent(void) +{ + do_indent(-tabsize); +} + +/* undo a cut, or re-do an uncut */ +void undo_cut(undo *u) +{ + /* If we cut the magicline may was well not crash :/ */ + if (!u->cutbuffer) + return; + + cutbuffer = copy_filestruct(u->cutbuffer); + + /* Compute cutbottom for the uncut using out copy */ + for (cutbottom = cutbuffer; cutbottom->next != NULL; cutbottom = cutbottom->next) + ; + + /* Get to where we need to uncut from */ + if (u->mark_set && u->mark_begin_lineno < u->lineno) + do_gotolinecolumn(u->mark_begin_lineno, u->mark_begin_x+1, FALSE, FALSE, FALSE, FALSE); + else + do_gotolinecolumn(u->lineno, u->begin+1, FALSE, FALSE, FALSE, FALSE); + + copy_from_filestruct(cutbuffer, cutbottom); + free_filestruct(cutbuffer); + cutbuffer = NULL; + +} + +/* Re-do a cut, or undo an uncut */ +void redo_cut(undo *u) { + int i; + filestruct *t, *c; + + /* If we cut the magicline may was well not crash :/ */ + if (!u->cutbuffer) + return; + + do_gotolinecolumn(u->lineno, u->begin+1, FALSE, FALSE, FALSE, FALSE); + openfile->mark_set = u->mark_set; + if (cutbuffer) + free(cutbuffer); + cutbuffer = NULL; + + /* Move ahead the same # lines we had if a marked cut */ + if (u->mark_set) { + for (i = 1, t = openfile->fileage; i != u->mark_begin_lineno; i++) + t = t->next; + openfile->mark_begin = t; + } else if (!u->to_end) { + /* Here we have a regular old potentially multi-line ^K cut. We'll + need to trick nano into thinking it's a marked cut to cut more + than one line again */ + for (c = u->cutbuffer, t = openfile->current; c->next != NULL && t->next != NULL; ) { + +#ifdef DEBUG + fprintf(stderr, "Advancing, lineno = %lu, data = \"%s\"\n", (unsigned long) t->lineno, t->data); +#endif + c = c->next; + t = t->next; + } + openfile->mark_begin = t; + openfile->mark_begin_x = 0; + openfile->mark_set = TRUE; + } + + openfile->mark_begin_x = u->mark_begin_x; + do_cut_text(FALSE, u->to_end, TRUE); + openfile->mark_set = FALSE; + openfile->mark_begin = NULL; + openfile->mark_begin_x = 0; + edit_refresh_needed = TRUE; +} + +/* Undo the last thing(s) we did */ +void do_undo(void) +{ + undo *u = openfile->current_undo; + filestruct *f = openfile->current, *t; + int len = 0; + char *undidmsg, *data; + filestruct *oldcutbuffer = cutbuffer, *oldcutbottom = cutbottom; + + if (!u) { + statusbar(_("Nothing in undo buffer!")); + return; + } + + + if (u->lineno <= f->lineno) + for (; f->prev != NULL && f->lineno != u->lineno; f = f->prev) + ; + else + for (; f->next != NULL && f->lineno != u->lineno; f = f->next) + ; + if (f->lineno != u->lineno) { + statusbar(_("Internal error: can't match line %d. Please save your work"), u->lineno); + return; + } +#ifdef DEBUG + fprintf(stderr, "data we're about to undo = \"%s\"\n", f->data); + fprintf(stderr, "Undo running for type %d\n", u->type); +#endif + + openfile->current_x = u->begin; + switch(u->type) { + case ADD: + undidmsg = _("text add"); + len = strlen(f->data) - strlen(u->strdata) + 1; + data = charalloc(len); + strncpy(data, f->data, u->begin); + strcpy(&data[u->begin], &f->data[u->begin + strlen(u->strdata)]); + free(f->data); + f->data = data; + break; + case DEL: + undidmsg = _("text delete"); + len = strlen(f->data) + strlen(u->strdata) + 1; + data = charalloc(len); + + 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; + if (u->xflags == UNDO_DEL_BACKSPACE) + openfile->current_x += strlen(u->strdata); + break; +#ifndef DISABLE_WRAPPING + case SPLIT: + undidmsg = _("line wrap"); + f->data = (char *) nrealloc(f->data, strlen(f->data) + strlen(u->strdata) + 1); + strcpy(&f->data[strlen(f->data) - 1], u->strdata); + if (u->strdata2 != NULL) + f->next->data = mallocstrcpy(f->next->data, u->strdata2); + else { + filestruct *foo = openfile->current->next; + unlink_node(foo); + delete_node(foo); + } + renumber(f); + break; +#endif /* DISABLE_WRAPPING */ + case UNSPLIT: + undidmsg = _("line join"); + t = make_new_node(f); + t->data = mallocstrcpy(NULL, u->strdata); + data = mallocstrncpy(NULL, f->data, u->begin); + data[u->begin] = '\0'; + free(f->data); + f->data = data; + splice_node(f, t, f->next); + renumber(f); + break; + case CUT: + undidmsg = _("text cut"); + undo_cut(u); + break; + case UNCUT: + undidmsg = _("text uncut"); + redo_cut(u); + break; + case ENTER: + undidmsg = _("line break"); + if (f->next) { + filestruct *foo = f->next; + f->data = (char *) nrealloc(f->data, strlen(f->data) + strlen(f->next->data) + 1); + strcat(f->data, f->next->data); + unlink_node(foo); + delete_node(foo); + } + break; + case INSERT: + undidmsg = _("text insert"); + cutbuffer = NULL; + cutbottom = NULL; + /* When we updated mark_begin_lineno in update_undo, it was effectively how many line + were inserted due to being partitioned before read_file was called. So we + add its value here */ + openfile->mark_begin = fsfromline(u->lineno + u->mark_begin_lineno - 1); + openfile->mark_begin_x = 0; + openfile->mark_set = TRUE; + do_gotolinecolumn(u->lineno, u->begin+1, FALSE, FALSE, FALSE, FALSE); + cut_marked(); + u->cutbuffer = cutbuffer; + u->cutbottom = cutbottom; + cutbuffer = oldcutbuffer; + cutbottom = oldcutbottom; + openfile->mark_set = FALSE; + break; + case REPLACE: + undidmsg = _("text replace"); + data = u->strdata; + u->strdata = f->data; + f->data = data; + break; + + default: + undidmsg = _("Internal error: unknown type. Please save your work"); + break; + + } + renumber(f); + do_gotolinecolumn(u->lineno, u->begin, FALSE, FALSE, FALSE, TRUE); + statusbar(_("Undid action (%s)"), undidmsg); + openfile->current_undo = openfile->current_undo->next; + openfile->last_action = OTHER; +} + +void do_redo(void) +{ + undo *u = openfile->undotop; + filestruct *f = openfile->current; + int len = 0; + char *undidmsg, *data; + + for (; u != NULL && u->next != openfile->current_undo; u = u->next) + ; + if (!u) { + statusbar(_("Nothing to re-do!")); + return; + } + if (u->next != openfile->current_undo) { + statusbar(_("Internal error: Redo setup failed. Please save your work")); + return; + } + + if (u->lineno <= f->lineno) + for (; f->prev != NULL && f->lineno != u->lineno; f = f->prev) + ; + else + for (; f->next != NULL && f->lineno != u->lineno; f = f->next) + ; + if (f->lineno != u->lineno) { + statusbar(_("Internal error: can't match line %d. Please save your work"), u->lineno); + return; + } +#ifdef DEBUG + fprintf(stderr, "data we're about to redo = \"%s\"\n", f->data); + fprintf(stderr, "Redo running for type %d\n", u->type); +#endif + + switch(u->type) { + case ADD: + undidmsg = _("text add"); + len = strlen(f->data) + strlen(u->strdata) + 1; + data = charalloc(len); + 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; + break; + case DEL: + undidmsg = _("text delete"); + len = strlen(f->data) + strlen(u->strdata) + 1; + data = charalloc(len); + strncpy(data, f->data, u->begin); + strcpy(&data[u->begin], &f->data[u->begin + strlen(u->strdata)]); + free(f->data); + f->data = data; + break; + case ENTER: + undidmsg = _("line break"); + do_gotolinecolumn(u->lineno, u->begin+1, FALSE, FALSE, FALSE, FALSE); + do_enter(TRUE); + break; +#ifndef DISABLE_WRAPPING + case SPLIT: + undidmsg = _("line wrap"); + if (u->xflags & UNDO_SPLIT_MADENEW) + prepend_wrap = TRUE; + do_wrap(f, TRUE); + renumber(f); + break; +#endif /* DISABLE_WRAPPING */ + case UNSPLIT: + undidmsg = _("line join"); + len = strlen(f->data) + strlen(u->strdata + 1); + data = charalloc(len); + strcpy(data, f->data); + strcat(data, u->strdata); + free(f->data); + f->data = data; + if (f->next != NULL) { + filestruct *tmp = f->next; + unlink_node(tmp); + delete_node(tmp); + } + renumber(f); + break; + case CUT: + undidmsg = _("text cut"); + redo_cut(u); + break; + case UNCUT: + undidmsg = _("text uncut"); + undo_cut(u); + break; + case REPLACE: + undidmsg = _("text replace"); + data = u->strdata; + u->strdata = f->data; + f->data = data; + break; + case INSERT: + undidmsg = _("text insert"); + do_gotolinecolumn(u->lineno, u->begin+1, FALSE, FALSE, FALSE, FALSE); + copy_from_filestruct(u->cutbuffer, u->cutbottom); + openfile->placewewant = xplustabs(); + break; + default: + undidmsg = _("Internal error: unknown type. Please save your work"); + break; + + } + do_gotolinecolumn(u->lineno, u->begin, FALSE, FALSE, FALSE, TRUE); + statusbar(_("Redid action (%s)"), undidmsg); + + openfile->current_undo = u; + openfile->last_action = OTHER; + +} +#endif /* !NANO_TINY */ + +/* Someone hits Enter *gasp!* */ +void do_enter(bool undoing) +{ + filestruct *newnode = make_new_node(openfile->current); + size_t extra = 0; + + assert(openfile->current != NULL && openfile->current->data != NULL); + +#ifndef NANO_TINY + if (!undoing) + add_undo(ENTER); + + + /* Do auto-indenting, like the neolithic Turbo Pascal editor. */ + if (ISSET(AUTOINDENT)) { + /* If we are breaking the line in the indentation, the new + * indentation should have only current_x characters, and + * current_x should not change. */ + extra = indent_length(openfile->current->data); + if (extra > openfile->current_x) + extra = openfile->current_x; + } +#endif + 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)) { + strncpy(newnode->data, openfile->current->data, extra); + openfile->totsize += mbstrlen(newnode->data); + } +#endif + null_at(&openfile->current->data, openfile->current_x); +#ifndef NANO_TINY + if (openfile->mark_set && openfile->current == + openfile->mark_begin && openfile->current_x < + openfile->mark_begin_x) { + openfile->mark_begin = newnode; + openfile->mark_begin_x += extra - openfile->current_x; + } +#endif + openfile->current_x = extra; + + if (openfile->current == openfile->filebot) + openfile->filebot = newnode; + splice_node(openfile->current, newnode, + openfile->current->next); + + renumber(openfile->current); + openfile->current = newnode; + + openfile->totsize++; + set_modified(); + + openfile->placewewant = xplustabs(); + + edit_refresh_needed = TRUE; +} + +#ifndef NANO_TINY +/* Send a SIGKILL (unconditional kill) to the forked process in + * execute_command(). */ +RETSIGTYPE cancel_command(int signal) +{ + if (kill(pid, SIGKILL) == -1) + nperror("kill"); +} + +/* Execute command in a shell. Return TRUE on success. */ +bool execute_command(const char *command) +{ + int fd[2]; + FILE *f; + char *shellenv; + struct sigaction oldaction, newaction; + /* Original and temporary handlers for SIGINT. */ + bool sig_failed = FALSE; + /* Did sigaction() fail without changing the signal handlers? */ + + /* Make our pipes. */ + if (pipe(fd) == -1) { + statusbar(_("Could not pipe")); + return FALSE; + } + + /* Check $SHELL for the shell to use. If it isn't set, use + * /bin/sh. Note that $SHELL should contain only a path, with no + * arguments. */ + shellenv = getenv("SHELL"); + if (shellenv == NULL) + shellenv = (char *) "/bin/sh"; + + /* Fork a child. */ + if ((pid = fork()) == 0) { + close(fd[0]); + dup2(fd[1], fileno(stdout)); + dup2(fd[1], fileno(stderr)); + + /* If execl() returns at all, there was an error. */ + execl(shellenv, tail(shellenv), "-c", command, NULL); + exit(0); + } + + /* Continue as parent. */ + close(fd[1]); + + if (pid == -1) { + close(fd[0]); + statusbar(_("Could not fork")); + return FALSE; + } + + /* Before we start reading the forked command's output, we set + * things up so that Ctrl-C will cancel the new process. */ + + /* Enable interpretation of the special control keys so that we get + * SIGINT when Ctrl-C is pressed. */ + enable_signals(); + + if (sigaction(SIGINT, NULL, &newaction) == -1) { + sig_failed = TRUE; + nperror("sigaction"); + } else { + newaction.sa_handler = cancel_command; + if (sigaction(SIGINT, &newaction, &oldaction) == -1) { + sig_failed = TRUE; + nperror("sigaction"); + } + } + + /* Note that now oldaction is the previous SIGINT signal handler, + * to be restored later. */ + + f = fdopen(fd[0], "rb"); + if (f == NULL) + nperror("fdopen"); + + read_file(f, 0, "stdin", TRUE, FALSE); + + if (wait(NULL) == -1) + nperror("wait"); + + if (!sig_failed && sigaction(SIGINT, &oldaction, NULL) == -1) + nperror("sigaction"); + + /* Restore the terminal to its previous state. In the process, + * disable interpretation of the special control keys so that we can + * use Ctrl-C for other things. */ + terminal_init(); + + return TRUE; +} + +/* Add a new undo struct to the top of the current pile */ +void add_undo(undo_type current_action) +{ + undo *u; + char *data; + openfilestruct *fs = openfile; + static undo *last_cutu = NULL; /* Last thing we cut to set up the undo for uncut */ + ssize_t wrap_loc; /* For calculating split beginning */ + + if (!ISSET(UNDOABLE)) + return; + + /* Ugh, if we were called while cutting not-to-end, non-marked and on the same lineno, + we need to abort here */ + u = fs->current_undo; + if (current_action == CUT && u && u->type == CUT + && !u->mark_set && u->lineno == fs->current->lineno) + return; + + /* Blow away the old undo stack if we are starting from the middle */ + while (fs->undotop != NULL && fs->undotop != fs->current_undo) { + undo *u2 = fs->undotop; + fs->undotop = fs->undotop->next; + if (u2->strdata != NULL) + free(u2->strdata); + if (u2->cutbuffer) + free_filestruct(u2->cutbuffer); + free(u2); + } + + /* Allocate and initialize a new undo type */ + u = (undo *) nmalloc(sizeof(undo)); + u->type = current_action; + u->lineno = fs->current->lineno; + u->begin = fs->current_x; + u->next = fs->undotop; + fs->undotop = u; + fs->current_undo = u; + u->strdata = NULL; + u->strdata2 = NULL; + u->cutbuffer = NULL; + u->cutbottom = NULL; + u->mark_set = 0; + u->mark_begin_lineno = 0; + u->mark_begin_x = 0; + u->xflags = 0; + u->to_end = FALSE; + + switch (u->type) { + /* We need to start copying data into the undo buffer or we wont be able + to restore it later */ + case ADD: + data = charalloc(2); + data[0] = fs->current->data[fs->current_x]; + data[1] = '\0'; + u->strdata = data; + break; + case DEL: + if (u->begin != strlen(fs->current->data)) { + data = mallocstrncpy(NULL, &fs->current->data[u->begin], 2); + data[1] = '\0'; + u->strdata = data; + break; + } + /* Else purposely fall into unsplit code */ + current_action = u->type = UNSPLIT; + case UNSPLIT: + if (fs->current->next) { + data = mallocstrcpy(NULL, fs->current->next->data); + u->strdata = data; + } + break; +#ifndef DISABLE_WRAPPING + case SPLIT: + wrap_loc = break_line(openfile->current->data, fill +#ifndef DISABLE_HELP + , FALSE +#endif + ); + u->strdata = mallocstrcpy(NULL, &openfile->current->data[wrap_loc]); + /* Don't both saving the next line if we're not prepending as a new line + will be created */ + if (prepend_wrap) + u->strdata2 = mallocstrcpy(NULL, fs->current->next->data); + u->begin = wrap_loc; + break; +#endif /* DISABLE_WRAPPING */ + case INSERT: + case REPLACE: + data = mallocstrcpy(NULL, fs->current->data); + u->strdata = data; + break; + case CUT: + u->mark_set = openfile->mark_set; + if (u->mark_set) { + u->mark_begin_lineno = openfile->mark_begin->lineno; + u->mark_begin_x = openfile->mark_begin_x; + } + u->to_end = (ISSET(CUT_TO_END)) ? TRUE : FALSE; + last_cutu = u; + break; + case UNCUT: + if (!last_cutu) + statusbar(_("Internal error: can't setup uncut. Please save your work.")); + else if (last_cutu->type == CUT) { + u->cutbuffer = last_cutu->cutbuffer; + u->cutbottom = last_cutu->cutbottom; + } + break; + case ENTER: + break; + case OTHER: + statusbar(_("Internal error: unknown type. Please save your work.")); + break; + } + +#ifdef DEBUG + fprintf(stderr, "fs->current->data = \"%s\", current_x = %lu, u->begin = %d, type = %d\n", + fs->current->data, (unsigned long) fs->current_x, u->begin, current_action); + fprintf(stderr, "left add_undo...\n"); +#endif + fs->last_action = current_action; +} + +/* Update an undo item, or determine whether a new one + is really needed and bounce the data to add_undo + instead. The latter functionality just feels + gimmicky and may just be more hassle than + it's worth, so it should be axed if needed. */ +void update_undo(undo_type action) +{ + undo *u; + char *data; + int len = 0; + openfilestruct *fs = openfile; + + if (!ISSET(UNDOABLE)) + return; + +#ifdef DEBUG + fprintf(stderr, "action = %d, fs->last_action = %d, openfile->current->lineno = %lu", + action, fs->last_action, (unsigned long) openfile->current->lineno); + if (fs->current_undo) + fprintf(stderr, "fs->current_undo->lineno = %lu\n", (unsigned long) fs->current_undo->lineno); + else + fprintf(stderr, "\n"); +#endif + + /* Change to an add if we're not using the same undo struct + that we should be using */ + if (action != fs->last_action + || (action != CUT && action != INSERT && action != SPLIT + && openfile->current->lineno != fs->current_undo->lineno)) { + add_undo(action); + return; + } + + assert(fs->undotop != NULL); + u = fs->undotop; + + switch (u->type) { + case ADD: +#ifdef DEBUG + fprintf(stderr, "fs->current->data = \"%s\", current_x = %lu, u->begin = %d\n", + fs->current->data, (unsigned long) fs->current_x, u->begin); +#endif + len = strlen(u->strdata) + 2; + data = (char *) nrealloc((void *) u->strdata, len * sizeof(char *)); + data[len-2] = fs->current->data[fs->current_x]; + data[len-1] = '\0'; + u->strdata = (char *) data; +#ifdef DEBUG + fprintf(stderr, "current undo data now \"%s\"\n", u->strdata); +#endif + break; + case DEL: + len = strlen(u->strdata) + 2; + assert(len > 2); + if (fs->current_x == u->begin) { + /* They're deleting */ + if (!u->xflags) + u->xflags = UNDO_DEL_DEL; + else if (u->xflags != UNDO_DEL_DEL) { + add_undo(action); + return; + } + data = charalloc(len); + strcpy(data, u->strdata); + data[len-2] = fs->current->data[fs->current_x];; + data[len-1] = '\0'; + free(u->strdata); + u->strdata = data; + } else if (fs->current_x == u->begin - 1) { + /* They're backspacing */ + if (!u->xflags) + u->xflags = UNDO_DEL_BACKSPACE; + else if (u->xflags != UNDO_DEL_BACKSPACE) { + add_undo(action); + return; + } + data = charalloc(len); + data[0] = fs->current->data[fs->current_x]; + strcpy(&data[1], u->strdata); + free(u->strdata); + u->strdata = data; + u->begin--; + } else { + /* They deleted something else on the line */ + add_undo(DEL); + return; + } +#ifdef DEBUG + fprintf(stderr, "current undo data now \"%s\"\nu->begin = %d\n", u->strdata, u->begin); +#endif + break; + case CUT: + if (!cutbuffer) + break; + if (u->cutbuffer) + free(u->cutbuffer); + u->cutbuffer = copy_filestruct(cutbuffer); + /* Compute cutbottom for the uncut using out copy */ + for (u->cutbottom = u->cutbuffer; u->cutbottom->next != NULL; u->cutbottom = u->cutbottom->next) + ; + break; + case REPLACE: + case UNCUT: + add_undo(action); + break; + case INSERT: + u->mark_begin_lineno = openfile->current->lineno; + break; +#ifndef DISABLE_WRAPPING + case SPLIT: + /* This will only be called if we made a completely new line, + and as such we should note that so we can destroy it later */ + u->xflags = UNDO_SPLIT_MADENEW; + break; +#endif /* DISABLE_WRAPPING */ + case UNSPLIT: + /* These cases are handled by the earlier check for a new line and action */ + case ENTER: + case OTHER: + break; + } + +#ifdef DEBUG + fprintf(stderr, "Done in udpate_undo (type was %d)\n", action); +#endif + if (fs->last_action != action) { +#ifdef DEBUG + fprintf(stderr, "Starting add_undo for new action as it does not match last_action\n"); +#endif + add_undo(action); + } + fs->last_action = action; +} + +#endif /* !NANO_TINY */ + +#ifndef DISABLE_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; +} + +/* We wrap the given line. Precondition: we assume the cursor has been + * moved forward since the last typed character. Return TRUE if we + * wrapped, and FALSE otherwise. */ +bool do_wrap(filestruct *line, bool undoing) +{ + size_t line_len; + /* The length of the line we wrap. */ + ssize_t wrap_loc; + /* The index of line->data where we wrap. */ +#ifndef NANO_TINY + const char *indent_string = NULL; + /* Indentation to prepend to the new line. */ + size_t indent_len = 0; + /* The length of indent_string. */ +#endif + const char *after_break; + /* The text after the wrap point. */ + size_t after_break_len; + /* The length of after_break. */ + bool prepending = FALSE; + /* Do we prepend to the next line? */ + const char *next_line = NULL; + /* The next line, minus indentation. */ + size_t next_line_len = 0; + /* The length of next_line. */ + char *new_line = NULL; + /* The line we create. */ + size_t new_line_len = 0; + /* The eventual length of new_line. */ + + /* 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! */ + assert(line != NULL && line->data != NULL); + + /* Save the length of the line. */ + line_len = strlen(line->data); + + /* Find the last blank where we can break the line. */ + wrap_loc = break_line(line->data, fill +#ifndef DISABLE_HELP + , FALSE +#endif + ); + + /* 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 (!undoing) + add_undo(SPLIT); + + /* If autoindent is turned on, and we're on the character just after + * the indentation, we don't wrap. */ + if (ISSET(AUTOINDENT)) { + /* Get the indentation of this line. */ + indent_string = line->data; + indent_len = indent_length(indent_string); + + if (wrap_loc == indent_len) + return FALSE; + } +#endif + + /* 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. */ + + /* after_break is the text that will be wrapped to the next line. */ + after_break = line->data + wrap_loc; + after_break_len = line_len - wrap_loc; + + assert(strlen(after_break) == after_break_len); + + /* 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 *end = after_break + move_mbleft(after_break, + after_break_len); + + /* If after_break doesn't end in a blank, make sure it ends in a + * space. */ + if (!is_blank_mbchar(end)) { + line_len++; + line->data = charealloc(line->data, line_len + 1); + line->data[line_len - 1] = ' '; + line->data[line_len] = '\0'; + after_break = line->data + wrap_loc; + after_break_len++; + openfile->totsize++; + } + + next_line = line->next->data; + next_line_len = strlen(next_line); + + if (after_break_len + next_line_len <= fill) { + prepending = TRUE; + new_line_len += next_line_len; + } + } + + /* new_line_len is now the length of the text that will be wrapped + * to the next line, plus (if we're prepending to it) the length of + * the text of the next line. */ + new_line_len += after_break_len; + +#ifndef NANO_TINY + if (ISSET(AUTOINDENT)) { + if (prepending) { + /* If we're prepending, the indentation will come from the + * next line. */ + indent_string = next_line; + indent_len = indent_length(indent_string); + next_line += indent_len; + } else { + /* Otherwise, it will come from this line, in which case + * we should increase new_line_len to make room for it. */ + new_line_len += indent_len; + openfile->totsize += mbstrnlen(indent_string, indent_len); + } + } +#endif + + /* Now we allocate the new line and copy the text into it. */ + new_line = charalloc(new_line_len + 1); + new_line[0] = '\0'; + +#ifndef NANO_TINY + if (ISSET(AUTOINDENT)) { + /* Copy the indentation. */ + strncpy(new_line, indent_string, indent_len); + new_line[indent_len] = '\0'; + new_line_len += indent_len; + } +#endif + + /* Copy all the text after the wrap point of the current line. */ + strcat(new_line, after_break); + + /* Break the current line at the wrap point. */ + null_at(&line->data, wrap_loc); + + if (prepending) { + if (!undoing) + update_undo(SPLIT); + /* If we're prepending, copy the text from the next line, minus + * the indentation that we already copied above. */ + strcat(new_line, next_line); + + free(line->next->data); + line->next->data = new_line; + + /* If the NO_NEWLINES flag isn't set, and text has been added to + * the magicline, make a new magicline. */ + if (!ISSET(NO_NEWLINES) && openfile->filebot->data[0] != '\0') + new_magicline(); + } else { + /* Otherwise, make a new line and copy the text after where we + * broke this line to the beginning of the new line. */ + splice_node(openfile->current, make_new_node(openfile->current), + openfile->current->next); + + /* If the current line is the last line of the file, move the + * last line of the file down to the next line. */ + if (openfile->filebot == openfile->current) + openfile->filebot = openfile->current->next; + + openfile->current->next->data = new_line; + + openfile->totsize++; + } + + /* Step 3, clean up. Reposition the cursor and mark, and do some + * other sundry things. */ + + /* Set the prepend_wrap flag, so that later wraps of this line will + * be prepended to the next line. */ + prepend_wrap = TRUE; + + /* Each line knows its number. We recalculate these if we inserted + * a new line. */ + if (!prepending) + renumber(line); + + /* If the cursor was after the break point, we must move it. We + * also clear the prepend_wrap flag in this case. */ + if (openfile->current_x > wrap_loc) { + prepend_wrap = FALSE; + + openfile->current = openfile->current->next; + openfile->current_x -= wrap_loc +#ifndef NANO_TINY + - indent_len +#endif + ; + openfile->placewewant = xplustabs(); + } + +#ifndef NANO_TINY + /* If the mark was on this line after the wrap point, we move it + * down. If it was on the next line and we prepended to that line, + * we move it right. */ + if (openfile->mark_set) { + if (openfile->mark_begin == line && openfile->mark_begin_x > + wrap_loc) { + openfile->mark_begin = line->next; + openfile->mark_begin_x -= wrap_loc - indent_len + 1; + } else if (prepending && openfile->mark_begin == line->next) + openfile->mark_begin_x += after_break_len; + } +#endif + + return TRUE; +} +#endif /* !DISABLE_WRAPPING */ + +#if !defined(DISABLE_HELP) || !defined(DISABLE_WRAPJUSTIFY) +/* 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 newline is TRUE. */ +ssize_t break_line(const char *line, ssize_t goal +#ifndef DISABLE_HELP + , bool newln +#endif + ) +{ + ssize_t blank_loc = -1; + /* Current tentative return value. Index of the last blank we + * found with short enough display width. */ + ssize_t cur_loc = 0; + /* Current index in line. */ + size_t cur_pos = 0; + /* Current column position in line. */ + int line_len; + + assert(line != NULL); + + while (*line != '\0' && goal >= cur_pos) { + line_len = parse_mbchar(line, NULL, &cur_pos); + + if (is_blank_mbchar(line) +#ifndef DISABLE_HELP + || (newln && *line == '\n') +#endif + ) { + blank_loc = cur_loc; + +#ifndef DISABLE_HELP + if (newln && *line == '\n') + break; +#endif + } + + line += line_len; + cur_loc += line_len; + } + + if (goal >= cur_pos) + /* In fact, the whole line displays shorter than goal. */ + return cur_loc; + +#ifndef DISABLE_HELP + if (newln && blank_loc <= 0) { + /* If blank was not found or was found only first character, + * force line break. */ + cur_loc -= line_len; + return cur_loc; + } +#endif + + if (blank_loc == -1) { + /* No blank was found that was short enough. */ + bool found_blank = FALSE; + ssize_t found_blank_loc = 0; + + while (*line != '\0') { + line_len = parse_mbchar(line, NULL, NULL); + + if (is_blank_mbchar(line) +#ifndef DISABLE_HELP + || (newln && *line == '\n') +#endif + ) { + if (!found_blank) + found_blank = TRUE; + found_blank_loc = cur_loc; + } else if (found_blank) + return found_blank_loc; + + line += line_len; + cur_loc += line_len; + } + + return -1; + } + + /* Move to the last blank after blank_loc, if there is one. */ + line -= cur_loc; + line += blank_loc; + line_len = parse_mbchar(line, NULL, NULL); + line += line_len; + + while (*line != '\0' && (is_blank_mbchar(line) +#ifndef DISABLE_HELP + || (newln && *line == '\n') +#endif + )) { +#ifndef DISABLE_HELP + if (newln && *line == '\n') + break; +#endif + + line_len = parse_mbchar(line, NULL, NULL); + + line += line_len; + blank_loc += line_len; + } + + return blank_loc; +} +#endif /* !DISABLE_HELP || !DISABLE_WRAPJUSTIFY */ + +#if !defined(NANO_TINY) || !defined(DISABLE_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 *blank_mb; + int blank_mb_len; + + assert(line != NULL); + + blank_mb = charalloc(mb_cur_max()); + + while (*line != '\0') { + blank_mb_len = parse_mbchar(line, blank_mb, NULL); + + if (!is_blank_mbchar(blank_mb)) + break; + + line += blank_mb_len; + len += blank_mb_len; + } + + free(blank_mb); + + return len; +} +#endif /* !NANO_TINY || !DISABLE_JUSTIFY */ + +#ifndef DISABLE_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 + + /* These four asserts are assumptions about the input data. */ + assert(paragraph != NULL); + assert(paragraph->data != NULL); + assert(skip < strlen(paragraph->data)); + assert(!is_blank_mbchar(paragraph->data + skip)); + + 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_set && openfile->mark_begin == + paragraph && openfile->mark_begin_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_set && openfile->mark_begin == + paragraph && openfile->mark_begin_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--; + } + } + } + + assert(*end == '\0'); + + *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_set && openfile->mark_begin == paragraph) { + openfile->mark_begin_x -= mark_shift; + if (openfile->mark_begin_x > new_end - new_paragraph_data) + openfile->mark_begin_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. + * + * Note that if !HAVE_REGEX_H then we match concatenated copies of + * quotestr. */ +size_t quote_length(const char *line) +{ +#ifdef HAVE_REGEX_H + 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; +#else /* !HAVE_REGEX_H */ + size_t qdepth = 0; + + /* Compute quote depth level. */ + while (strncmp(line + qdepth, quotestr, quotelen) == 0) + qdepth += quotelen; + return qdepth; +#endif /* !HAVE_REGEX_H */ +} + +/* a_line and b_line are lines of text. The quotation part of a_line is + * the first a_quote characters. Check that the quotation part of + * b_line is the same. */ +bool quotes_match(const char *a_line, size_t a_quote, const char + *b_line) +{ + /* Here is the assumption about a_quote. */ + assert(a_quote == quote_length(a_line)); + + return (a_quote == quote_length(b_line) && + strncmp(a_line, b_line, a_quote) == 0); +} + +/* We assume a_line and b_line have no quote part. Then, we return + * whether b_line could follow a_line in a paragraph. */ +bool indents_match(const char *a_line, size_t a_indent, const char + *b_line, size_t b_indent) +{ + assert(a_indent == indent_length(a_line)); + assert(b_indent == indent_length(b_line)); + + return (b_indent <= a_indent && + strncmp(a_line, b_line, b_indent) == 0); +} + +/* Is foo the beginning of a paragraph? + * + * A line of text consists of a "quote part", followed by an + * "indentation part", followed by text. The functions quote_length() + * and indent_length() calculate these parts. + * + * A line is "part of a paragraph" if it has a part not in the quote + * part or the indentation. + * + * A line is "the beginning of a paragraph" if it is part of a + * paragraph and + * 1) it is the top line of the file, or + * 2) the line above it is not part of a paragraph, or + * 3) the line above it does not have precisely the same quote + * part, or + * 4) the indentation of this line is not an initial substring of + * the indentation of the previous line, or + * 5) this line has no quote part and some indentation, and + * autoindent isn't turned on. + * The reason for number 5) is that if autoindent isn't turned on, + * then an indented line is expected to start a paragraph, as in + * books. Thus, nano can justify an indented paragraph only if + * autoindent is turned on. */ +bool begpar(const filestruct *const foo) +{ + size_t quote_len, indent_len, temp_id_len; + + if (foo == NULL) + return FALSE; + + /* Case 1). */ + if (foo == openfile->fileage) + return TRUE; + + quote_len = quote_length(foo->data); + indent_len = indent_length(foo->data + quote_len); + + /* Not part of a paragraph. */ + if (foo->data[quote_len + indent_len] == '\0') + return FALSE; + + /* Case 3). */ + if (!quotes_match(foo->data, quote_len, foo->prev->data)) + return TRUE; + + temp_id_len = indent_length(foo->prev->data + quote_len); + + /* Case 2) or 5) or 4). */ + if (foo->prev->data[quote_len + temp_id_len] == '\0' || + (quote_len == 0 && indent_len > 0 +#ifndef NANO_TINY + && !ISSET(AUTOINDENT) +#endif + ) || !indents_match(foo->prev->data + quote_len, temp_id_len, + foo->data + quote_len, indent_len)) + return TRUE; + + return FALSE; +} + +/* Is foo inside a paragraph? */ +bool inpar(const filestruct *const foo) +{ + size_t quote_len; + + if (foo == NULL) + return FALSE; + + quote_len = quote_length(foo->data); + + return (foo->data[quote_len + indent_length(foo->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; + /* Generic loop variable. */ + 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 old_mark_set = openfile->mark_set; + ssize_t mb_lineno_save = 0; + size_t mark_begin_x_save = 0; + + if (old_mark_set) { + mb_lineno_save = openfile->mark_begin->lineno; + mark_begin_x_save = openfile->mark_begin_x; + } +#endif + + /* par_len will be one greater than the number of lines between + * current and filebot if filebot is the last line in the + * paragraph. */ + assert(par_len > 0 && openfile->current->lineno + par_len <= + openfile->filebot->lineno + 1); + + /* 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's filestruct to the + * justify buffer. */ + move_to_filestruct(&jusbuffer, &jusbottom, top, 0, bot, + (i == 1 && bot == openfile->filebot) ? strlen(bot->data) : 0); + + /* Copy the paragraph back to the current buffer's filestruct from + * the justify buffer. */ + copy_from_filestruct(jusbuffer, jusbottom); + + /* 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 (old_mark_set && + openfile->current->lineno == mb_lineno_save) { + openfile->mark_begin = openfile->current; + openfile->mark_begin_x = mark_begin_x_save; + } +#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 (old_mark_set && top->lineno == mb_lineno_save) { + openfile->mark_begin = top; + openfile->mark_begin_x = mark_begin_x_save; + } +#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. + * + * See the comment at begpar() for more about when a line is the + * beginning of 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. */ + ssize_t current_y_save; + /* The y-coordinate at the beginning of the paragraph we search + * for. */ + +#ifdef HAVE_REGEX_H + if (quoterc != 0) { + statusbar(_("Bad quote string %s: %s"), quotestr, quoteerr); + return FALSE; + } +#endif + + assert(openfile->current != NULL); + + /* 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 (!inpar(openfile->current->prev)) + return FALSE; + if (openfile->current != openfile->fileage) + openfile->current = openfile->current->prev; + } + } + + /* If the current line isn't the first line of the paragraph, move + * back to the first line of the paragraph. */ + if (!begpar(openfile->current)) + 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; + current_y_save = openfile->current_y; + 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; + openfile->current_y = current_y_save; + + /* Save the values of quote_len and par_len. */ + assert(quote != NULL && par != NULL); + + *quote = quote_len; + *par = par_len; + + return TRUE; +} + +/* If full_justify is TRUE, justify the entire file. Otherwise, justify + * the current paragraph. */ +void do_justify(bool full_justify) +{ + 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. */ + + /* We save these variables to be restored if the user + * unjustifies. */ + filestruct *edittop_save = openfile->edittop; + filestruct *current_save = openfile->current; + size_t current_x_save = openfile->current_x; + size_t pww_save = openfile->placewewant; + size_t totsize_save = openfile->totsize; +#ifndef NANO_TINY + filestruct *mark_begin_save = openfile->mark_begin; + size_t mark_begin_x_save = openfile->mark_begin_x; +#endif + bool modified_save = openfile->modified; + + int kbinput; + bool meta_key, func_key, s_or_t, ran_func, finished; + const sc *s; + + /* 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; + + while (TRUE) { + size_t i; + /* Generic loop variable. */ + filestruct *curr_first_par_line; + /* The first line of the current paragraph. */ + size_t quote_len; + /* Length of the initial quotation of the current + * paragraph. */ + size_t indent_len; + /* Length of the initial indentation of the current + * paragraph. */ + size_t par_len; + /* Number of lines in the current paragraph. */ + ssize_t break_pos; + /* Where we will break lines. */ + char *indent_string; + /* The first indentation that doesn't match the initial + * indentation of the current paragraph. This is put at the + * beginning of every line broken off the first justified + * line of the paragraph. Note that this works because a + * paragraph can only contain two indentations at most: the + * initial one, and a different one starting on a line after + * the first. See the comment at begpar() for more about + * when a line is part of a paragraph. */ + + /* Find the first line of the paragraph to be justified. That + * is the start of this paragraph if we're in one, or the start + * of the next otherwise. Save the quote length and paragraph + * length (number of lines). Don't refresh the screen yet, + * since we'll do that after we justify. + * + * If the search failed, we do one of two things. If we're + * justifying the whole file, and we've found at least one + * paragraph, it means that we should justify all the way to the + * last line of the file, so set the last line of the text to be + * justified to the last line of the file and break out of the + * loop. Otherwise, it means that there are no paragraph(s) to + * justify, so refresh the screen and get out. */ + if (!find_paragraph("e_len, &par_len)) { + if (full_justify && first_par_line != NULL) { + last_par_line = openfile->filebot; + break; + } else { + edit_refresh_needed = TRUE; + return; + } + } + + /* 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); + + /* If we haven't already done it, 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. */ + if (first_par_line == NULL) { + 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; + } + + /* Set curr_first_par_line to the first line of the current + * paragraph. */ + curr_first_par_line = openfile->current; + + /* Initialize indent_string to a blank string. */ + indent_string = mallocstrcpy(NULL, ""); + + /* Find the first indentation in the paragraph that doesn't + * match the indentation of the first line, and save it in + * indent_string. If all the indentations are the same, save + * the indentation of the first line in indent_string. */ + { + const filestruct *indent_line = openfile->current; + bool past_first_line = FALSE; + + for (i = 0; i < par_len; i++) { + indent_len = quote_len + + indent_length(indent_line->data + quote_len); + + if (indent_len != strlen(indent_string)) { + indent_string = mallocstrncpy(indent_string, + indent_line->data, indent_len + 1); + indent_string[indent_len] = '\0'; + + if (past_first_line) + break; + } + + if (indent_line == openfile->current) + past_first_line = TRUE; + + indent_line = indent_line->next; + } + } + + /* Now tack all the lines of the paragraph together, skipping + * the quoting and indentation on all lines after the first. */ + for (i = 0; i < par_len - 1; i++) { + filestruct *next_line = openfile->current->next; + size_t line_len = strlen(openfile->current->data); + size_t next_line_len = + strlen(openfile->current->next->data); + + indent_len = quote_len + + indent_length(openfile->current->next->data + + quote_len); + + next_line_len -= indent_len; + openfile->totsize -= indent_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] != ' ') { + line_len++; + openfile->current->data = + charealloc(openfile->current->data, + line_len + 1); + openfile->current->data[line_len - 1] = ' '; + openfile->current->data[line_len] = '\0'; + openfile->totsize++; + } + + openfile->current->data = + charealloc(openfile->current->data, line_len + + next_line_len + 1); + strcat(openfile->current->data, next_line->data + + indent_len); + + /* Don't destroy edittop or filebot! */ + if (next_line == openfile->edittop) + openfile->edittop = openfile->current; + if (next_line == openfile->filebot) + openfile->filebot = openfile->current; + +#ifndef NANO_TINY + /* Adjust the mark coordinates to compensate for the change + * in the next line. */ + if (openfile->mark_set && openfile->mark_begin == + next_line) { + openfile->mark_begin = openfile->current; + openfile->mark_begin_x += line_len - indent_len; + } +#endif + + unlink_node(next_line); + delete_node(next_line); + + /* If we've removed the next line, we need to go through + * this line again. */ + i--; + + par_len--; + openfile->totsize--; + } + + /* 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); + + indent_len = strlen(indent_string); + + /* 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 + indent_len, + fill - strnlenpt(openfile->current->data, indent_len) +#ifndef DISABLE_HELP + , FALSE +#endif + ); + + /* We can't break the line, or don't need to, so get out. */ + if (break_pos == -1 || break_pos + indent_len == line_len) + break; + + /* Move forward to the character after the indentation and + * just after the space. */ + break_pos += indent_len + 1; + + assert(break_pos <= line_len); + + /* Make a new line, and copy the text after where we're + * going to break this line to the beginning of the new + * line. */ + splice_node(openfile->current, + make_new_node(openfile->current), + openfile->current->next); + + /* If this paragraph is non-quoted, and autoindent isn't + * turned on, set the indentation length to zero so that the + * indentation is treated as part of the line. */ + if (quote_len == 0 +#ifndef NANO_TINY + && !ISSET(AUTOINDENT) +#endif + ) + indent_len = 0; + + /* Copy the text after where we're going to break the + * current line to the next line. */ + openfile->current->next->data = charalloc(indent_len + 1 + + line_len - break_pos); + strncpy(openfile->current->next->data, indent_string, + indent_len); + strcpy(openfile->current->next->data + indent_len, + openfile->current->data + break_pos); + + par_len++; + openfile->totsize += indent_len + 1; + +#ifndef NANO_TINY + /* Adjust the mark coordinates to compensate for the change + * in the current line. */ + if (openfile->mark_set && openfile->mark_begin == + openfile->current && openfile->mark_begin_x > + break_pos) { + openfile->mark_begin = openfile->current->next; + openfile->mark_begin_x -= break_pos - indent_len; + } +#endif + + /* Break the current line. */ + null_at(&openfile->current->data, break_pos); + + /* If the current line is the last line of the file, move + * the last line of the file down to the next line. */ + if (openfile->filebot == openfile->current) + openfile->filebot = openfile->filebot->next; + + /* Go to the next line. */ + par_len--; + openfile->current_y++; + openfile->current = openfile->current->next; + } + + /* We're done breaking lines, so we don't need indent_string + * anymore. */ + free(indent_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_y++; + openfile->current = openfile->current->next; + } else + openfile->current_x = strlen(openfile->current->data); + + /* Renumber the lines of the now-justified current paragraph, + * since both find_paragraph() and edit_refresh() need the line + * numbers to be right. */ + renumber(curr_first_par_line); + + /* 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; + } + + /* We are now done justifying the paragraph or the file, so clean + * up. current_y and totsize have been maintained above. If we + * actually justified something, set last_par_line to the new end of + * the paragraph. */ + if (first_par_line != NULL) + last_par_line = openfile->current; + + edit_refresh(); + +#ifndef NANO_TINY + /* We're going to set jump_buf so that we return here after a + * SIGWINCH instead of to main(). Indicate this. */ + jump_buf_main = FALSE; + + /* Return here after a SIGWINCH. */ + sigsetjmp(jump_buf, 1); +#endif + + statusbar(_("Can now UnJustify!")); + + /* If constant cursor position display is on, make sure the current + * cursor position will be properly displayed on the statusbar. */ + if (ISSET(CONST_UPDATE)) + do_cursorpos(TRUE); + + /* Display the shortcut list with UnJustify. */ + shortcut_init(TRUE); + display_main_list(); + + /* Now get a keystroke and see if it's unjustify. If not, put back + * the keystroke and return. */ + kbinput = do_input(&meta_key, &func_key, &s_or_t, &ran_func, + &finished, FALSE); + s = get_shortcut(currmenu, &kbinput, &meta_key, &func_key); + + if (s && s->scfunc == DO_UNCUT_TEXT) { + /* Splice the justify buffer back into the file, but only if we + * actually justified something. */ + if (first_par_line != NULL) { + filestruct *top_save; + + /* Partition the filestruct so that it contains only the + * text of the justified paragraph. */ + filepart = partition_filestruct(first_par_line, 0, + last_par_line, filebot_inpar ? + strlen(last_par_line->data) : 0); + + /* Remove the text of the justified paragraph, and + * replace it with the text in the justify buffer. */ + free_filestruct(openfile->fileage); + openfile->fileage = jusbuffer; + openfile->filebot = jusbottom; + + top_save = openfile->fileage; + + /* Unpartition the filestruct so that it contains all the + * text again. Note that the justified paragraph has been + * replaced with the unjustified paragraph. */ + unpartition_filestruct(&filepart); + + /* Renumber starting with the beginning line of the old + * partition. */ + renumber(top_save); + + /* Restore the justify we just did (ungrateful user!). */ + openfile->edittop = edittop_save; + openfile->current = current_save; + openfile->current_x = current_x_save; + openfile->placewewant = pww_save; + openfile->totsize = totsize_save; +#ifndef NANO_TINY + if (openfile->mark_set) { + openfile->mark_begin = mark_begin_save; + openfile->mark_begin_x = mark_begin_x_save; + } +#endif + openfile->modified = modified_save; + + /* Clear the justify buffer. */ + jusbuffer = NULL; + + if (!openfile->modified) + titlebar(NULL); + edit_refresh_needed = TRUE; + } + } else { + unget_kbinput(kbinput, meta_key, func_key); + + /* Blow away the text in the justify buffer. */ + free_filestruct(jusbuffer); + jusbuffer = NULL; + } + + blank_statusbar(); + + /* Display the shortcut list with UnCut. */ + shortcut_init(FALSE); + display_main_list(); +} + +/* 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 /* !DISABLE_JUSTIFY */ + +#ifndef DISABLE_SPELLER +/* A word is misspelled in the file. Let the user replace it. We + * return FALSE if the user cancels. */ +bool do_int_spell_fix(const char *word) +{ + char *save_search, *save_replace; + size_t match_len, current_x_save = openfile->current_x; + size_t pww_save = openfile->placewewant; + bool meta_key = FALSE, func_key = FALSE; + filestruct *edittop_save = openfile->edittop; + filestruct *current_save = openfile->current; + /* Save where we are. */ + bool canceled = FALSE; + /* The return value. */ + bool case_sens_set = ISSET(CASE_SENSITIVE); +#ifndef NANO_TINY + bool backwards_search_set = ISSET(BACKWARDS_SEARCH); +#endif +#ifdef HAVE_REGEX_H + bool regexp_set = ISSET(USE_REGEXP); +#endif +#ifndef NANO_TINY + bool old_mark_set = openfile->mark_set; + bool added_magicline = FALSE; + /* Whether we added a magicline after filebot. */ + 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 + + /* Make sure spell-check is case sensitive. */ + SET(CASE_SENSITIVE); + +#ifndef NANO_TINY + /* Make sure spell-check goes forward only. */ + UNSET(BACKWARDS_SEARCH); +#endif +#ifdef HAVE_REGEX_H + /* Make sure spell-check doesn't use regular expressions. */ + UNSET(USE_REGEXP); +#endif + + /* Save the current search/replace strings. */ + search_init_globals(); + save_search = last_search; + save_replace = last_replace; + + /* Set the search/replace strings to the misspelled word. */ + last_search = mallocstrcpy(NULL, word); + last_replace = mallocstrcpy(NULL, word); + +#ifndef NANO_TINY + if (old_mark_set) { + /* If the mark is on, partition the filestruct so that it + * contains only the marked text; if the NO_NEWLINES flag isn't + * set, keep track of whether the text will have a magicline + * added when we're done correcting misspelled words; and + * turn the mark off. */ + mark_order((const filestruct **)&top, &top_x, + (const filestruct **)&bot, &bot_x, &right_side_up); + filepart = partition_filestruct(top, top_x, bot, bot_x); + if (!ISSET(NO_NEWLINES)) + added_magicline = (openfile->filebot->data[0] != '\0'); + openfile->mark_set = FALSE; + } +#endif + + /* Start from the top of the file. */ + openfile->edittop = openfile->fileage; + openfile->current = openfile->fileage; + openfile->current_x = (size_t)-1; + openfile->placewewant = 0; + + /* Find the first whole occurrence of word. */ + findnextstr_wrap_reset(); + while (findnextstr(TRUE, FALSE, openfile->fileage, 0, word, + &match_len)) { + if (is_whole_word(openfile->current_x, openfile->current->data, + word)) { + size_t xpt = xplustabs(); + char *exp_word = display_string(openfile->current->data, + xpt, strnlenpt(openfile->current->data, + openfile->current_x + match_len) - xpt, FALSE); + + edit_refresh(); + + do_replace_highlight(TRUE, exp_word); + + /* Allow all instances of the word to be corrected. */ + canceled = (do_prompt(FALSE, +#ifndef DISABLE_TABCOMP + TRUE, +#endif + MSPELL, word, + &meta_key, &func_key, +#ifndef NANO_TINY + NULL, +#endif + edit_refresh, _("Edit a replacement")) == -1); + + do_replace_highlight(FALSE, exp_word); + + free(exp_word); + + if (!canceled && strcmp(word, answer) != 0) { + openfile->current_x--; + do_replace_loop(TRUE, &canceled, openfile->current, + &openfile->current_x, word); + } + + break; + } + } + +#ifndef NANO_TINY + if (old_mark_set) { + /* If the mark was on, the NO_NEWLINES flag isn't set, and we + * added a magicline, remove it now. */ + if (!ISSET(NO_NEWLINES) && added_magicline) + remove_magicline(); + + /* Put the beginning and the end of the mark at the beginning + * and the end of the spell-checked text. */ + if (openfile->fileage == openfile->filebot) + bot_x += top_x; + if (right_side_up) { + openfile->mark_begin_x = top_x; + current_x_save = bot_x; + } else { + current_x_save = top_x; + openfile->mark_begin_x = bot_x; + } + + /* Unpartition the filestruct so that it contains all the text + * again, and turn the mark back on. */ + unpartition_filestruct(&filepart); + openfile->mark_set = TRUE; + } +#endif + + /* Restore the search/replace strings. */ + free(last_search); + last_search = save_search; + free(last_replace); + last_replace = save_replace; + + /* Restore where we were. */ + openfile->edittop = edittop_save; + openfile->current = current_save; + openfile->current_x = current_x_save; + openfile->placewewant = pww_save; + + /* Restore case sensitivity setting. */ + if (!case_sens_set) + UNSET(CASE_SENSITIVE); + +#ifndef NANO_TINY + /* Restore search/replace direction. */ + if (backwards_search_set) + SET(BACKWARDS_SEARCH); +#endif +#ifdef HAVE_REGEX_H + /* Restore regular expression usage setting. */ + if (regexp_set) + SET(USE_REGEXP); +#endif + + return !canceled; +} + +/* 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) + 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 spell 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 remove mixed case. If + * this isn't portable, let me know. */ + 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]); + + /* Process the spelling errors. */ + 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) { + if (!do_int_spell_fix(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) + do_int_spell_fix(read_buff_word); + + free(read_buff); + search_replace_abort(); + edit_refresh_needed = TRUE; + + /* Process the end of the spell process. */ + 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\""); + + /* Otherwise... */ + return NULL; + + close_pipes_and_exit: + /* Don't leak any handles. */ + close(tempfile_fd); + 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 current_y_save = openfile->current_y; + ssize_t lineno_save = openfile->current->lineno; + pid_t pid_spell; + char *ptr; + static int arglen = 3; + static char **spellargs = NULL; +#ifndef NANO_TINY + bool old_mark_set = openfile->mark_set; + bool added_magicline = FALSE; + /* Whether we added a magicline after filebot. */ + 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; + ssize_t mb_lineno_save = 0; + /* We're going to close the current file, and open the output of + * the alternate spell command. The line that mark_begin points + * to will be freed, so we save the line number and restore it + * afterwards. */ + size_t totsize_save = openfile->totsize; + /* Our saved value of totsize, used when we spell-check a marked + * selection. */ + + if (old_mark_set) { + /* If the mark is on, save the number of the line it starts on, + * and then turn the mark off. */ + mb_lineno_save = openfile->mark_begin->lineno; + openfile->mark_set = FALSE; + } +#endif + + if (openfile->totsize == 0) { + statusbar(_("Finished checking spelling")); + return NULL; + } + + endwin(); + + /* Set up an argument list to pass execvp(). */ + if (spellargs == NULL) { + spellargs = (char **)nmalloc(arglen * sizeof(char *)); + + spellargs[0] = strtok(alt_speller, " "); + while ((ptr = strtok(NULL, " ")) != NULL) { + arglen++; + spellargs = (char **)nrealloc(spellargs, arglen * + sizeof(char *)); + spellargs[arglen - 3] = ptr; + } + spellargs[arglen - 1] = NULL; + } + spellargs[arglen - 2] = tempfile_name; + + /* Start a new process for the alternate speller. */ + if ((pid_spell = fork()) == 0) { + /* Start alternate spell program; we are using $PATH. */ + execvp(spellargs[0], spellargs); + + /* Should not be reached, if alternate speller is found!!! */ + exit(1); + } + + /* If we couldn't fork, get out. */ + if (pid_spell < 0) + return _("Could not fork"); + +#ifndef NANO_TINY + /* Don't handle a pending SIGWINCH until the alternate spell checker + * is finished and we've loaded the spell-checked file back in. */ + allow_pending_sigwinch(FALSE); +#endif + + /* 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(); + + /* Turn the cursor back on for sure. */ + curs_set(1); + + /* The screen might have been resized. If it has, reinitialize all + * the windows based on the new screen dimensions. */ + window_init(); + + if (!WIFEXITED(alt_spell_status) || + WEXITSTATUS(alt_spell_status) != 0) { + char *alt_spell_error; + char *invoke_error = _("Error invoking \"%s\""); + +#ifndef NANO_TINY + /* Turn the mark back on if it was on before. */ + openfile->mark_set = old_mark_set; +#endif + + alt_spell_error = + charalloc(strlen(invoke_error) + + strlen(alt_speller) + 1); + sprintf(alt_spell_error, invoke_error, alt_speller); + return alt_spell_error; + } + +#ifndef NANO_TINY + if (old_mark_set) { + /* If the mark is on, partition the filestruct so that it + * contains only the marked text; if the NO_NEWLINES flag isn't + * set, keep track of whether the text will have a magicline + * added when we're done correcting misspelled words; and + * turn the mark off. */ + mark_order((const filestruct **)&top, &top_x, + (const filestruct **)&bot, &bot_x, &right_side_up); + filepart = partition_filestruct(top, top_x, bot, bot_x); + if (!ISSET(NO_NEWLINES)) + added_magicline = (openfile->filebot->data[0] != '\0'); + + /* Get the number of characters in the marked text, and subtract + * it from the saved value of totsize. */ + totsize_save -= get_totsize(top, bot); + } +#endif + + /* Replace the text of the current buffer with the spell-checked + * text. */ + replace_buffer(tempfile_name); + +#ifndef NANO_TINY + if (old_mark_set) { + filestruct *top_save = openfile->fileage; + + /* If the mark was on, the NO_NEWLINES flag isn't set, and we + * added a magicline, remove it now. */ + if (!ISSET(NO_NEWLINES) && added_magicline) + remove_magicline(); + + /* Put the beginning and the end of the mark at the beginning + * and the end of the spell-checked text. */ + if (openfile->fileage == openfile->filebot) + bot_x += top_x; + if (right_side_up) { + openfile->mark_begin_x = top_x; + current_x_save = bot_x; + } else { + current_x_save = top_x; + openfile->mark_begin_x = bot_x; + } + + /* Unpartition the filestruct so that it contains all the text + * again. Note that we've replaced the marked text originally + * in the partition with the spell-checked marked text in the + * temp file. */ + unpartition_filestruct(&filepart); + + /* Renumber starting with the beginning line of the old + * partition. Also add the number of characters in the + * spell-checked marked text to the saved value of totsize, and + * then make that saved value the actual value. */ + renumber(top_save); + totsize_save += openfile->totsize; + openfile->totsize = totsize_save; + + /* Assign mark_begin to the line where the mark began before. */ + do_gotopos(mb_lineno_save, openfile->mark_begin_x, + current_y_save, 0); + openfile->mark_begin = openfile->current; + + /* Assign mark_begin_x to the location in mark_begin where the + * mark began before, adjusted for any shortening of the + * line. */ + openfile->mark_begin_x = openfile->current_x; + + /* Turn the mark back on. */ + openfile->mark_set = TRUE; + } +#endif + + /* Go back to the old position, and mark the file as modified. */ + do_gotopos(lineno_save, current_x_save, current_y_save, pww_save); + set_modified(); + +#ifndef NANO_TINY + /* Handle a pending SIGWINCH again. */ + allow_pending_sigwinch(TRUE); +#endif + + 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 = safe_tempfile(&temp_file); + const char *spell_msg; + + if (ISSET(RESTRICTED)) { + nano_disabled_msg(); + return; + } + + if (temp == NULL) { + statusbar(_("Error writing temp file: %s"), strerror(errno)); + return; + } + + status = +#ifndef NANO_TINY + openfile->mark_set ? write_marked_file(temp, temp_file, TRUE, + OVERWRITE) : +#endif + write_file(temp, temp_file, TRUE, OVERWRITE, FALSE); + + if (!status) { + statusbar(_("Error writing temp file: %s"), strerror(errno)); + free(temp); + return; + } + + spell_msg = (alt_speller != NULL) ? do_alt_speller(temp) : + do_int_speller(temp); + unlink(temp); + free(temp); + + currmenu = MMAIN; + + /* If the spell-checker printed any error messages onscreen, make + * sure that they're cleared off. */ + total_refresh(); + + if (spell_msg != NULL) { + if (errno == 0) + /* Don't display an error message of "Success". */ + statusbar(_("Spell checking failed: %s"), spell_msg); + else + statusbar(_("Spell checking failed: %s: %s"), spell_msg, + strerror(errno)); + } else + statusbar(_("Finished checking spelling")); +} +#endif /* !DISABLE_SPELLER */ + +#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; + bool old_mark_set = openfile->mark_set; + filestruct *top, *bot; + size_t top_x, bot_x; + + if (old_mark_set) { + /* If the mark is on, partition the filestruct so that it + * contains only the marked text, and turn the mark off. */ + mark_order((const filestruct **)&top, &top_x, + (const filestruct **)&bot, &bot_x, NULL); + filepart = partition_filestruct(top, top_x, bot, bot_x); + openfile->mark_set = FALSE; + } + + /* 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(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 (old_mark_set) { + nlines = openfile->filebot->lineno - + openfile->fileage->lineno + 1; + chars = get_totsize(openfile->fileage, openfile->filebot); + + /* Unpartition the filestruct so that it contains all the text + * again, and turn the mark back on. */ + unpartition_filestruct(&filepart); + openfile->mark_set = TRUE; + } 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. */ + statusbar(_("%sWords: %lu Lines: %ld Chars: %lu"), old_mark_set ? + _("In Selection: ") : "", (unsigned long)words, (long)nlines, + (unsigned long)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")); + + /* Read in all the verbatim characters. */ + kbinput = get_verbatim_kbinput(edit, &kbinput_len); + + /* If constant cursor position display is on, make sure the current + * cursor position will be properly displayed on the statusbar. + * Otherwise, blank the statusbar. */ + if (ISSET(CONST_UPDATE)) + do_cursorpos(TRUE); + else { + blank_statusbar(); + wnoutrefresh(bottomwin); + } + + /* 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); +} + |