/************************************************************************** * nano.c -- This file is part of GNU nano. * * * * Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, * * 2008, 2009, 2010, 2011, 2013, 2014 Free Software Foundation, Inc. * * Copyright (C) 2014, 2015, 2016 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 "revision.h" #include #include #include #include #include #include #include #include #ifdef ENABLE_UTF8 #include #endif #ifdef HAVE_TERMIOS_H #include #endif #include #ifndef NANO_TINY #include #endif #ifndef DISABLE_MOUSE static int oldinterval = -1; /* Used to store the user's original mouse click interval. */ #endif #ifndef DISABLE_NANORC static bool no_rcfiles = FALSE; /* Should we ignore all rcfiles? */ #endif #ifdef HAVE_TERMIOS_H static struct termios oldterm; #else # define tcsetattr(...) # define tcgetattr(...) #endif /* The user's original terminal settings. */ static struct sigaction act; /* Used to set up all our fun signal handlers. */ /* Create a new filestruct node. Note that we do not set prevnode->next * to the new line. */ filestruct *make_new_node(filestruct *prevnode) { filestruct *newnode = (filestruct *)nmalloc(sizeof(filestruct)); newnode->data = NULL; newnode->prev = prevnode; newnode->next = NULL; newnode->lineno = (prevnode != NULL) ? prevnode->lineno + 1 : 1; #ifndef DISABLE_COLOR newnode->multidata = NULL; #endif return newnode; } /* Make a copy of a filestruct node. */ filestruct *copy_node(const filestruct *src) { filestruct *dst; dst = (filestruct *)nmalloc(sizeof(filestruct)); dst->data = mallocstrcpy(NULL, src->data); dst->next = src->next; dst->prev = src->prev; dst->lineno = src->lineno; #ifndef DISABLE_COLOR dst->multidata = NULL; #endif return dst; } /* Splice a new node into an existing linked list of filestructs. */ void splice_node(filestruct *afterthis, filestruct *newnode) { newnode->next = afterthis->next; newnode->prev = afterthis; if (afterthis->next != NULL) afterthis->next->prev = newnode; afterthis->next = newnode; /* Update filebot when inserting a node at the end of file. */ if (openfile && openfile->filebot == afterthis) openfile->filebot = newnode; } /* Disconnect a node from a linked list of filestructs and delete it. */ void unlink_node(filestruct *fileptr) { if (fileptr->prev != NULL) fileptr->prev->next = fileptr->next; if (fileptr->next != NULL) fileptr->next->prev = fileptr->prev; /* Update filebot when removing a node at the end of file. */ if (openfile && openfile->filebot == fileptr) openfile->filebot = fileptr->prev; delete_node(fileptr); } /* Free the data structures in the given node. */ void delete_node(filestruct *fileptr) { free(fileptr->data); #ifndef DISABLE_COLOR free(fileptr->multidata); #endif free(fileptr); } /* Duplicate a whole filestruct. */ filestruct *copy_filestruct(const filestruct *src) { filestruct *head, *copy; copy = copy_node(src); copy->prev = NULL; head = copy; src = src->next; while (src != NULL) { copy->next = copy_node(src); copy->next->prev = copy; copy = copy->next; src = src->next; } copy->next = NULL; return head; } /* Free a whole linked list of filestructs. */ void free_filestruct(filestruct *src) { if (src == NULL) return; while (src->next != NULL) { src = src->next; delete_node(src->prev); } delete_node(src); } /* Renumber all entries in a filestruct, starting with fileptr. */ void renumber(filestruct *fileptr) { ssize_t line; if (fileptr == NULL) return; line = (fileptr->prev == NULL) ? 0 : fileptr->prev->lineno; assert(fileptr != fileptr->next); for (; fileptr != NULL; fileptr = fileptr->next) fileptr->lineno = ++line; } /* Partition a filestruct so that it begins at (top, top_x) and ends at * (bot, bot_x). */ partition *partition_filestruct(filestruct *top, size_t top_x, filestruct *bot, size_t bot_x) { partition *p; assert(top != NULL && bot != NULL && openfile->fileage != NULL && openfile->filebot != NULL); /* Initialize the partition. */ p = (partition *)nmalloc(sizeof(partition)); /* If the top and bottom of the partition are different from the top * and bottom of the filestruct, save the latter and then set them * to top and bot. */ if (top != openfile->fileage) { p->fileage = openfile->fileage; openfile->fileage = top; } else p->fileage = NULL; if (bot != openfile->filebot) { p->filebot = openfile->filebot; openfile->filebot = bot; } else p->filebot = NULL; /* Remember which line is above the top of the partition, detach the * top of the partition from it, and save the text before top_x. */ p->top_prev = top->prev; top->prev = NULL; p->top_data = mallocstrncpy(NULL, top->data, top_x + 1); p->top_data[top_x] = '\0'; /* Remember which line is below the bottom of the partition, detach the * bottom of the partition from it, and save the text after bot_x. */ p->bot_next = bot->next; bot->next = NULL; p->bot_data = mallocstrcpy(NULL, bot->data + bot_x); /* Remove all text after bot_x at the bottom of the partition. */ bot->data[bot_x] = '\0'; /* Remove all text before top_x at the top of the partition. */ charmove(top->data, top->data + top_x, strlen(top->data) - top_x + 1); /* Return the partition. */ return p; } /* Unpartition a filestruct so that it begins at (fileage, 0) and ends * at (filebot, strlen(filebot->data)) again. */ void unpartition_filestruct(partition **p) { assert(p != NULL && openfile->fileage != NULL && openfile->filebot != NULL); /* Reattach the line above the top of the partition, and restore the * text before top_x from top_data. Free top_data when we're done * with it. */ openfile->fileage->prev = (*p)->top_prev; if (openfile->fileage->prev != NULL) openfile->fileage->prev->next = openfile->fileage; openfile->fileage->data = charealloc(openfile->fileage->data, strlen((*p)->top_data) + strlen(openfile->fileage->data) + 1); charmove(openfile->fileage->data + strlen((*p)->top_data), openfile->fileage->data, strlen(openfile->fileage->data) + 1); strncpy(openfile->fileage->data, (*p)->top_data, strlen((*p)->top_data)); free((*p)->top_data); /* Reattach the line below the bottom of the partition, and restore * the text after bot_x from bot_data. Free bot_data when we're * done with it. */ openfile->filebot->next = (*p)->bot_next; if (openfile->filebot->next != NULL) openfile->filebot->next->prev = openfile->filebot; openfile->filebot->data = charealloc(openfile->filebot->data, strlen(openfile->filebot->data) + strlen((*p)->bot_data) + 1); strcat(openfile->filebot->data, (*p)->bot_data); free((*p)->bot_data); /* Restore the top and bottom of the filestruct, if they were * different from the top and bottom of the partition. */ if ((*p)->fileage != NULL) openfile->fileage = (*p)->fileage; if ((*p)->filebot != NULL) openfile->filebot = (*p)->filebot; /* Uninitialize the partition. */ free(*p); *p = NULL; } /* Move all the text between (top, top_x) and (bot, bot_x) in the * current filestruct to a filestruct beginning with file_top and ending * with file_bot. If no text is between (top, top_x) and (bot, bot_x), * don't do anything. */ void extract_buffer(filestruct **file_top, filestruct **file_bot, filestruct *top, size_t top_x, filestruct *bot, size_t bot_x) { filestruct *top_save; bool edittop_inside; #ifndef NANO_TINY bool mark_inside = FALSE; bool same_line = FALSE; #endif assert(file_top != NULL && file_bot != NULL && top != NULL && bot != NULL); /* If (top, top_x)-(bot, bot_x) doesn't cover any text, get out. */ if (top == bot && top_x == bot_x) return; /* Partition the filestruct so that it contains only the text from * (top, top_x) to (bot, bot_x), keep track of whether the top of * the edit window is inside the partition, and keep track of * whether the mark begins inside the partition. */ filepart = partition_filestruct(top, top_x, bot, bot_x); edittop_inside = (openfile->edittop->lineno >= openfile->fileage->lineno && openfile->edittop->lineno <= openfile->filebot->lineno); #ifndef NANO_TINY if (openfile->mark_set) { mark_inside = (openfile->mark_begin->lineno >= openfile->fileage->lineno && openfile->mark_begin->lineno <= openfile->filebot->lineno && (openfile->mark_begin != openfile->fileage || openfile->mark_begin_x >= top_x) && (openfile->mark_begin != openfile->filebot || openfile->mark_begin_x <= bot_x)); same_line = (openfile->mark_begin == openfile->fileage); } #endif /* Subtract the number of characters in the text from the file size. */ openfile->totsize -= get_totsize(top, bot); if (*file_top == NULL) { /* If file_top is empty, just move all the text directly into * it. This is equivalent to tacking the text in top onto the * (lack of) text at the end of file_top. */ *file_top = openfile->fileage; *file_bot = openfile->filebot; /* Renumber, starting with file_top. */ renumber(*file_top); } else { filestruct *file_bot_save = *file_bot; /* Otherwise, tack the text in top onto the text at the end of * file_bot. */ (*file_bot)->data = charealloc((*file_bot)->data, strlen((*file_bot)->data) + strlen(openfile->fileage->data) + 1); strcat((*file_bot)->data, openfile->fileage->data); /* Attach the line after top to the line after file_bot. Then, * if there's more than one line after top, move file_bot down * to bot. */ (*file_bot)->next = openfile->fileage->next; if ((*file_bot)->next != NULL) { (*file_bot)->next->prev = *file_bot; *file_bot = openfile->filebot; } delete_node(openfile->fileage); /* Renumber, starting with the line after the original file_bot. */ renumber(file_bot_save->next); } /* Since the text has now been saved, remove it from the filestruct. */ openfile->fileage = make_new_node(NULL); openfile->fileage->data = mallocstrcpy(NULL, ""); openfile->filebot = openfile->fileage; /* Restore the current line and cursor position. If the mark begins * inside the partition, set the beginning of the mark to where the * saved text used to start. */ openfile->current = openfile->fileage; openfile->current_x = top_x; #ifndef NANO_TINY if (mark_inside) { openfile->mark_begin = openfile->current; openfile->mark_begin_x = openfile->current_x; } else if (same_line) /* Update the pointer to this partially cut line. */ openfile->mark_begin = openfile->current; #endif top_save = openfile->fileage; /* Unpartition the filestruct so that it contains all the text * again, minus the saved text. */ unpartition_filestruct(&filepart); /* If the top of the edit window was inside the old partition, put * it in range of current. */ if (edittop_inside) { adjust_viewport(STATIONARY); refresh_needed = TRUE; } /* Renumber, starting with the beginning line of the old partition. */ renumber(top_save); /* If the text doesn't end with a magicline, and it should, add one. */ if (!ISSET(NO_NEWLINES) && openfile->filebot->data[0] != '\0') new_magicline(); } /* Meld the given buffer into the current file buffer * at the current cursor position. */ void ingraft_buffer(filestruct *somebuffer) { filestruct *top_save; size_t current_x_save = openfile->current_x; bool edittop_inside; #ifndef NANO_TINY bool right_side_up = FALSE, single_line = FALSE; #endif assert(somebuffer != NULL); #ifndef NANO_TINY /* Keep track of whether the mark begins inside the partition and * will need adjustment. */ if (openfile->mark_set) { filestruct *top, *bot; size_t top_x, bot_x; mark_order((const filestruct **)&top, &top_x, (const filestruct **)&bot, &bot_x, &right_side_up); single_line = (top == bot); } #endif /* Partition the filestruct so that it contains no text, and remember * whether the current line is at the top of the edit window. */ filepart = partition_filestruct(openfile->current, openfile->current_x, openfile->current, openfile->current_x); edittop_inside = (openfile->edittop == openfile->fileage); free_filestruct(openfile->fileage); /* Put the top and bottom of the current filestruct at the top and * bottom of the passed buffer. */ openfile->fileage = somebuffer; openfile->filebot = openfile->fileage; while (openfile->filebot->next != NULL) openfile->filebot = openfile->filebot->next; /* Put the cursor at the end of the pasted text. */ openfile->current = openfile->filebot; openfile->current_x = strlen(openfile->filebot->data); /* Refresh the mark's pointer, and compensate the mark's * x coordinate for the change in the current line. */ if (openfile->fileage == openfile->filebot) { #ifndef NANO_TINY if (openfile->mark_set && single_line) { openfile->mark_begin = openfile->current; if (!right_side_up) openfile->mark_begin_x += openfile->current_x; } #endif /* When the pasted stuff contains no newline, adjust the cursor's * x coordinate for the text that is before the pasted stuff. */ openfile->current_x += current_x_save; } #ifndef NANO_TINY else if (openfile->mark_set && single_line) { if (right_side_up) openfile->mark_begin = openfile->fileage; else { openfile->mark_begin = openfile->current; openfile->mark_begin_x += openfile->current_x - current_x_save; } } #endif /* Add the number of characters in the copied text to the file size. */ openfile->totsize += get_totsize(openfile->fileage, openfile->filebot); /* If we pasted onto the first line of the edit window, the corresponding * struct has been freed, so... point at the start of the copied text. */ if (edittop_inside) openfile->edittop = openfile->fileage; top_save = openfile->fileage; /* Unpartition the filestruct so that it contains all the text * again, plus the copied text. */ unpartition_filestruct(&filepart); /* Renumber, starting with the beginning line of the old partition. */ renumber(top_save); /* If the text doesn't end with a magicline, and it should, add one. */ if (!ISSET(NO_NEWLINES) && openfile->filebot->data[0] != '\0') new_magicline(); } /* Meld a copy of the given buffer into the current file buffer. */ void copy_from_buffer(filestruct *somebuffer) { filestruct *the_copy = copy_filestruct(somebuffer); ingraft_buffer(the_copy); } /* Create a new openfilestruct node. */ openfilestruct *make_new_opennode(void) { return (openfilestruct *)nmalloc(sizeof(openfilestruct)); } /* Unlink a node from the rest of the openfilestruct, and delete it. */ void unlink_opennode(openfilestruct *fileptr) { assert(fileptr != fileptr->prev && fileptr != fileptr->next); fileptr->prev->next = fileptr->next; fileptr->next->prev = fileptr->prev; delete_opennode(fileptr); } /* Free all the memory in the given open-file node. */ void delete_opennode(openfilestruct *fileptr) { free(fileptr->filename); free_filestruct(fileptr->fileage); #ifndef NANO_TINY free(fileptr->current_stat); free(fileptr->lock_filename); /* Free the undo stack. */ discard_until(NULL, fileptr); #endif free(fileptr); } /* Display a warning about a key disabled in view mode. */ void print_view_warning(void) { statusbar(_("Key is invalid in view mode")); } /* Indicate that something is disabled in restricted mode. */ void show_restricted_warning(void) { statusbar(_("This function is disabled in restricted mode")); beep(); } #ifdef DISABLE_HELP /* Indicate that help texts are unavailable. */ void say_there_is_no_help(void) { statusbar(_("Help is not available")); } #endif /* Make nano exit gracefully. */ void finish(void) { /* Blank the statusbar and (if applicable) the shortcut list, * and move the cursor to the last line of the screen. */ blank_statusbar(); blank_bottombars(); wrefresh(bottomwin); endwin(); /* Restore the old terminal settings. */ tcsetattr(0, TCSANOW, &oldterm); #ifndef DISABLE_HISTORIES if (ISSET(HISTORYLOG)) save_history(); if (ISSET(POS_HISTORY)) { update_poshistory(openfile->filename, openfile->current->lineno, xplustabs() + 1); save_poshistory(); } #endif #ifdef DEBUG thanks_for_all_the_fish(); #endif /* Get out. */ exit(0); } /* Make nano die gracefully. */ void die(const char *msg, ...) { va_list ap; endwin(); /* Restore the old terminal settings. */ tcsetattr(0, TCSANOW, &oldterm); va_start(ap, msg); vfprintf(stderr, msg, ap); va_end(ap); #ifndef NANO_TINY /* If the current buffer has a lockfile, remove it. */ if (openfile && ISSET(LOCKING) && openfile->lock_filename) delete_lockfile(openfile->lock_filename); #endif /* If the current file buffer was modified, save it. */ if (openfile && openfile->modified) { /* If the filestruct is partitioned, unpartition it first. */ if (filepart != NULL) unpartition_filestruct(&filepart); die_save_file(openfile->filename, openfile->current_stat); } #ifndef DISABLE_MULTIBUFFER /* Save all of the other modified file buffers, if any. */ if (openfile != NULL) { openfilestruct *firstone = openfile; while (openfile->next != firstone) { openfile = openfile->next; #ifndef NANO_TINY if (ISSET(LOCKING) && openfile->lock_filename) delete_lockfile(openfile->lock_filename); #endif if (openfile->modified) die_save_file(openfile->filename, openfile->current_stat); } } #endif /* Abandon the building. */ exit(1); } /* Save the current file under the name specified in die_filename, which * is modified to be unique if necessary. */ void die_save_file(const char *die_filename, struct stat *die_stat) { char *targetname; bool failed = TRUE; /* If we're using restricted mode, don't write any emergency backup * files, since that would allow reading from or writing to files * not specified on the command line. */ if (ISSET(RESTRICTED)) return; /* If we can't save, we have really bad problems, but we might as * well try. */ if (*die_filename == '\0') die_filename = "nano"; targetname = get_next_filename(die_filename, ".save"); if (*targetname != '\0') failed = !write_file(targetname, NULL, TRUE, OVERWRITE, TRUE); if (!failed) fprintf(stderr, _("\nBuffer written to %s\n"), targetname); else if (*targetname != '\0') fprintf(stderr, _("\nBuffer not written to %s: %s\n"), targetname, strerror(errno)); else fprintf(stderr, _("\nBuffer not written: %s\n"), _("Too many backup files?")); #ifndef NANO_TINY /* Try and chmod/chown the save file to the values of the original file, * but don't worry if it fails because we're supposed to be bailing as * fast as possible. */ if (die_stat) { IGNORE_CALL_RESULT(chmod(targetname, die_stat->st_mode)); IGNORE_CALL_RESULT(chown(targetname, die_stat->st_uid, die_stat->st_gid)); } #endif free(targetname); } /* Initialize the three window portions nano uses. */ void window_init(void) { /* First delete existing windows, in case of resizing. */ delwin(topwin); topwin = NULL; delwin(edit); delwin(bottomwin); /* If the terminal is very flat, don't set up a titlebar. */ if (LINES < 3) { editwinrows = 1; /* Set up two subwindows. If the terminal is just one line, * edit window and statusbar window will cover each other. */ edit = newwin(1, COLS, 0, 0); bottomwin = newwin(1, COLS, LINES - 1, 0); } else { int toprows = (ISSET(MORE_SPACE) ? 1 : (LINES < 6) ? 1 : 2); int bottomrows = (ISSET(NO_HELP) ? 1 : (LINES < 5) ? 1 : 3); editwinrows = LINES - toprows - bottomrows; /* Set up the normal three subwindows. */ topwin = newwin(toprows, COLS, 0, 0); edit = newwin(editwinrows, COLS, toprows, 0); bottomwin = newwin(bottomrows, COLS, toprows + editwinrows, 0); } /* In case the terminal shrunk, make sure the status line is clear. */ blank_statusbar(); wnoutrefresh(bottomwin); /* Turn the keypad on for the windows, if necessary. */ if (!ISSET(REBIND_KEYPAD)) { keypad(topwin, TRUE); keypad(edit, TRUE); keypad(bottomwin, TRUE); } #ifndef DISABLE_WRAPJUSTIFY /* Set up the wrapping point, accounting for screen width when negative. */ fill = wrap_at; if (fill <= 0) fill += COLS; if (fill < 0) fill = 0; #endif } #ifndef DISABLE_MOUSE /* Disable mouse support. */ void disable_mouse_support(void) { mousemask(0, NULL); mouseinterval(oldinterval); } /* Enable mouse support. */ void enable_mouse_support(void) { mousemask(ALL_MOUSE_EVENTS, NULL); oldinterval = mouseinterval(50); } /* Initialize mouse support. Enable it if the USE_MOUSE flag is set, * and disable it otherwise. */ void mouse_init(void) { if (ISSET(USE_MOUSE)) enable_mouse_support(); else disable_mouse_support(); } #endif /* !DISABLE_MOUSE */ /* Print one usage string to the screen. This cuts down on duplicate * strings to translate, and leaves out the parts that shouldn't be * translatable (i.e. the flag names). */ void print_opt(const char *shortflag, const char *longflag, const char *desc) { printf(" %s\t", shortflag); if (strlenpt(shortflag) < 8) printf("\t"); printf("%s\t", longflag); if (strlenpt(longflag) < 8) printf("\t\t"); else if (strlenpt(longflag) < 16) printf("\t"); if (desc != NULL) printf("%s", _(desc)); printf("\n"); } /* Explain how to properly use nano and its command-line options. */ void usage(void) { printf(_("Usage: nano [OPTIONS] [[+LINE[,COLUMN]] FILE]...\n\n")); /* TRANSLATORS: The next two strings are part of the --help output. * It's best to keep its lines within 80 characters. */ printf(_("To place the cursor on a specific line of a file, put the line number with\n" "a '+' before the filename. The column number can be added after a comma.\n")); printf(_("When the first filename is '-', nano reads data from standard input.\n\n")); printf(_("Option\t\tGNU long option\t\tMeaning\n")); #ifndef NANO_TINY print_opt("-A", "--smarthome", /* TRANSLATORS: The next forty or so strings are option descriptions * for the --help output. Try to keep them at most 40 characters. */ N_("Enable smart home key")); if (!ISSET(RESTRICTED)) { print_opt("-B", "--backup", N_("Save backups of existing files")); print_opt(_("-C "), _("--backupdir="), N_("Directory for saving unique backup files")); } #endif print_opt("-D", "--boldtext", N_("Use bold instead of reverse video text")); #ifndef NANO_TINY print_opt("-E", "--tabstospaces", N_("Convert typed tabs to spaces")); #endif #ifndef DISABLE_MULTIBUFFER if (!ISSET(RESTRICTED)) print_opt("-F", "--multibuffer", N_("Read a file into a new buffer by default")); #endif #ifndef NANO_TINY print_opt("-G", "--locking", N_("Use (vim-style) lock files")); #endif #ifndef DISABLE_HISTORIES if (!ISSET(RESTRICTED)) print_opt("-H", "--historylog", N_("Log & read search/replace string history")); #endif #ifndef DISABLE_NANORC if (!ISSET(RESTRICTED)) print_opt("-I", "--ignorercfiles", N_("Don't look at nanorc files")); #endif print_opt("-K", "--rebindkeypad", N_("Fix numeric keypad key confusion problem")); print_opt("-L", "--nonewlines", N_("Don't add newlines to the ends of files")); #ifndef NANO_TINY print_opt("-N", "--noconvert", N_("Don't convert files from DOS/Mac format")); #endif print_opt("-O", "--morespace", N_("Use one more line for editing")); #ifndef DISABLE_HISTORIES if (!ISSET(RESTRICTED)) print_opt("-P", "--positionlog", N_("Log & read location of cursor position")); #endif #ifndef DISABLE_JUSTIFY print_opt(_("-Q "), _("--quotestr="), N_("Quoting string")); #endif if (!ISSET(RESTRICTED)) print_opt("-R", "--restricted", N_("Restricted mode")); #ifndef NANO_TINY print_opt("-S", "--smooth", N_("Scroll by line instead of half-screen")); #endif print_opt(_("-T <#cols>"), _("--tabsize=<#cols>"), N_("Set width of a tab to #cols columns")); #ifndef NANO_TINY print_opt("-U", "--quickblank", N_("Do quick statusbar blanking")); #endif print_opt("-V", "--version", N_("Print version information and exit")); #ifndef NANO_TINY print_opt("-W", "--wordbounds", N_("Detect word boundaries more accurately")); print_opt(_("-X "), _("--wordchars="), N_("Which other characters are word parts")); #endif #ifndef DISABLE_COLOR if (!ISSET(RESTRICTED)) print_opt(_("-Y "), _("--syntax="), N_("Syntax definition to use for coloring")); #endif print_opt("-c", "--constantshow", N_("Constantly show cursor position")); print_opt("-d", "--rebinddelete", N_("Fix Backspace/Delete confusion problem")); #ifndef DISABLE_BROWSER if (!ISSET(RESTRICTED)) print_opt("-g", "--showcursor", N_("Show cursor in file browser")); #endif print_opt("-h", "--help", N_("Show this help text and exit")); #ifndef NANO_TINY print_opt("-i", "--autoindent", N_("Automatically indent new lines")); print_opt("-k", "--cut", N_("Cut from cursor to end of line")); #endif #ifdef ENABLE_LINENUMBERS print_opt("-l", "--linenumbers", N_("Show line numbers in front of the text")); #endif #ifndef DISABLE_MOUSE print_opt("-m", "--mouse", N_("Enable the use of the mouse")); #endif print_opt("-n", "--noread", N_("Do not read the file (only write it)")); #ifndef DISABLE_OPERATINGDIR print_opt(_("-o "), _("--operatingdir="), N_("Set operating directory")); #endif print_opt("-p", "--preserve", N_("Preserve XON (^Q) and XOFF (^S) keys")); #ifndef DISABLE_NANORC if (!ISSET(RESTRICTED)) print_opt("-q", "--quiet", N_("Silently ignore startup issues like rc file errors")); #endif #ifndef DISABLE_WRAPJUSTIFY print_opt(_("-r <#cols>"), _("--fill=<#cols>"), N_("Set hard-wrapping point at column #cols")); #endif #ifndef DISABLE_SPELLER if (!ISSET(RESTRICTED)) print_opt(_("-s "), _("--speller="), N_("Enable alternate speller")); #endif print_opt("-t", "--tempfile", N_("Auto save on exit, don't prompt")); #ifndef NANO_TINY print_opt("-u", "--unix", N_("Save a file by default in Unix format")); #endif print_opt("-v", "--view", N_("View mode (read-only)")); #ifndef DISABLE_WRAPPING print_opt("-w", "--nowrap", N_("Don't hard-wrap long lines")); #endif print_opt("-x", "--nohelp", N_("Don't show the two help lines")); if (!ISSET(RESTRICTED)) print_opt("-z", "--suspend", N_("Enable suspension")); #ifndef NANO_TINY print_opt("-$", "--softwrap", N_("Enable soft line wrapping")); #endif } /* Display the current version of nano, the date and time it was * compiled, contact information for it, and the configuration options * it was compiled with. */ void version(void) { #ifdef REVISION printf(" GNU nano from git, %s\n", REVISION); #else printf(_(" GNU nano, version %s\n"), VERSION); #endif printf(" (C) 1999..2016 Free Software Foundation, Inc.\n"); printf(_(" (C) 2014..%s the contributors to nano\n"), "2017"); printf( _(" Email: nano@nano-editor.org Web: https://nano-editor.org/")); printf(_("\n Compiled options:")); #ifdef NANO_TINY printf(" --enable-tiny"); #ifndef DISABLE_BROWSER printf(" --enable-browser"); #endif #ifndef DISABLE_COLOR printf(" --enable-color"); #endif #ifndef DISABLE_EXTRA printf(" --enable-extra"); #endif #ifndef DISABLE_HELP printf(" --enable-help"); #endif #ifndef DISABLE_HISTORIES printf(" --enable-histories"); #endif #ifndef DISABLE_JUSTIFY printf(" --enable-justify"); #endif #ifdef HAVE_LIBMAGIC printf(" --enable-libmagic"); #endif #ifdef ENABLE_LINENUMBERS printf(" --enable-linenumbers"); #endif #ifndef DISABLE_MOUSE printf(" --enable-mouse"); #endif #ifndef DISABLE_NANORC printf(" --enable-nanorc"); #endif #ifndef DISABLE_MULTIBUFFER printf(" --enable-multibuffer"); #endif #ifndef DISABLE_OPERATINGDIR printf(" --enable-operatingdir"); #endif #ifndef DISABLE_SPELLER printf(" --enable-speller"); #endif #ifndef DISABLE_TABCOMP printf(" --enable-tabcomp"); #endif #ifndef DISABLE_WRAPPING printf(" --enable-wrapping"); #endif #else /* !NANO_TINY */ #ifdef DISABLE_BROWSER printf(" --disable-browser"); #endif #ifdef DISABLE_COLOR printf(" --disable-color"); #endif #ifndef ENABLE_COMMENT printf(" --disable-comment"); #endif #ifdef DISABLE_EXTRA printf(" --disable-extra"); #endif #ifdef DISABLE_HELP printf(" --disable-help"); #endif #ifdef DISABLE_HISTORIES printf(" --disable-histories"); #endif #ifdef DISABLE_JUSTIFY printf(" --disable-justify"); #endif #ifndef HAVE_LIBMAGIC printf(" --disable-libmagic"); #endif #ifndef ENABLE_LINENUMBERS printf(" --disable-linenumbers"); #endif #ifdef DISABLE_MOUSE printf(" --disable-mouse"); #endif #ifdef DISABLE_MULTIBUFFER printf(" --disable-multibuffer"); #endif #ifdef DISABLE_NANORC printf(" --disable-nanorc"); #endif #ifdef DISABLE_OPERATINGDIR printf(" --disable-operatingdir"); #endif #ifdef DISABLE_SPELLER printf(" --disable-speller"); #endif #ifdef DISABLE_TABCOMP printf(" --disable-tabcomp"); #endif #ifndef ENABLE_WORDCOMPLETION printf(" --disable-wordcomp"); #endif #ifdef DISABLE_WRAPPING printf(" --disable-wrapping"); #endif #endif /* !NANO_TINY */ #ifdef DISABLE_ROOTWRAPPING printf(" --disable-wrapping-as-root"); #endif #ifdef DEBUG printf(" --enable-debug"); #endif #ifndef ENABLE_NLS printf(" --disable-nls"); #endif #ifdef ENABLE_UTF8 printf(" --enable-utf8"); #else printf(" --disable-utf8"); #endif #ifdef USE_SLANG printf(" --with-slang"); #endif printf("\n"); } /* If the current file buffer has been modified, and the TEMP_FILE flag * isn't set, ask whether or not to save the file buffer. If the * TEMP_FILE flag is set and the current file has a name, save it * unconditionally. Then, if more than one file buffer is open, close * the current file buffer and switch to the next one. If only one file * buffer is open, exit from nano. */ void do_exit(void) { int i; /* If the file hasn't been modified, pretend the user chose not to * save. */ if (!openfile->modified) i = 0; /* If the TEMP_FILE flag is set and the current file has a name, * pretend the user chose to save. */ else if (openfile->filename[0] != '\0' && ISSET(TEMP_FILE)) i = 1; /* Otherwise, ask the user whether or not to save. */ else { /* If the TEMP_FILE flag is set, and the current file doesn't * have a name, warn the user before prompting for a name. */ if (ISSET(TEMP_FILE)) warn_and_shortly_pause(_("No file name")); i = do_yesno_prompt(FALSE, _("Save modified buffer? " "(Answering \"No\" will DISCARD changes.) ")); } #ifdef DEBUG dump_filestruct(openfile->fileage); #endif /* If the user chose not to save, or if the user chose to save and * the save succeeded, we're ready to exit. */ if (i == 0 || (i == 1 && do_writeout(TRUE))) close_and_go(); else if (i != 1) statusbar(_("Cancelled")); } /* Close the current buffer, and terminate nano if it was the last. */ void close_and_go(void) { #ifndef NANO_TINY /* If there is a lockfile, remove it. */ if (ISSET(LOCKING) && openfile->lock_filename) delete_lockfile(openfile->lock_filename); #endif #ifndef DISABLE_MULTIBUFFER /* If there are no more open file buffers, jump off a cliff. */ if (!close_buffer()) #endif finish(); } /* Another placeholder for function mapping. */ void do_cancel(void) { ; } static struct sigaction pager_oldaction, pager_newaction; /* Original and temporary handlers for SIGINT. */ static bool pager_sig_failed = FALSE; /* Did sigaction() fail without changing the signal handlers? */ static bool pager_input_aborted = FALSE; /* Did someone invoke the pager and abort it via ^C? */ /* Things which need to be run regardless of whether * we finished the stdin pipe correctly or not. */ void finish_stdin_pager(void) { FILE *f; int ttystdin; /* Read whatever we did get from stdin. */ f = fopen("/dev/stdin", "rb"); if (f == NULL) nperror("fopen"); read_file(f, 0, "stdin", TRUE, FALSE); openfile->edittop = openfile->fileage; ttystdin = open("/dev/tty", O_RDONLY); if (!ttystdin) die(_("Couldn't reopen stdin from keyboard, sorry\n")); dup2(ttystdin,0); close(ttystdin); if (!pager_input_aborted) tcgetattr(0, &oldterm); if (!pager_sig_failed && sigaction(SIGINT, &pager_oldaction, NULL) == -1) nperror("sigaction"); terminal_init(); doupdate(); } /* Cancel reading from stdin like a pager. */ RETSIGTYPE cancel_stdin_pager(int signal) { pager_input_aborted = TRUE; } /* Let nano read stdin for the first file at least. */ void stdin_pager(void) { endwin(); if (!pager_input_aborted) tcsetattr(0, TCSANOW, &oldterm); fprintf(stderr, _("Reading from stdin, ^C to abort\n")); #ifndef NANO_TINY /* Enable interpretation of the special control keys so that * we get SIGINT when Ctrl-C is pressed. */ enable_signals(); #endif /* Set things up so that SIGINT will cancel the new process. */ if (sigaction(SIGINT, NULL, &pager_newaction) == -1) { pager_sig_failed = TRUE; nperror("sigaction"); } else { pager_newaction.sa_handler = cancel_stdin_pager; if (sigaction(SIGINT, &pager_newaction, &pager_oldaction) == -1) { pager_sig_failed = TRUE; nperror("sigaction"); } } open_buffer("", FALSE); finish_stdin_pager(); } /* Initialize the signal handlers. */ void signal_init(void) { /* Trap SIGINT and SIGQUIT because we want them to do useful things. */ memset(&act, 0, sizeof(struct sigaction)); act.sa_handler = SIG_IGN; sigaction(SIGINT, &act, NULL); #ifdef SIGQUIT sigaction(SIGQUIT, &act, NULL); #endif /* Trap SIGHUP and SIGTERM because we want to write the file out. */ act.sa_handler = handle_hupterm; #ifdef SIGHUP sigaction(SIGHUP, &act, NULL); #endif sigaction(SIGTERM, &act, NULL); #ifndef NANO_TINY /* Trap SIGWINCH because we want to handle window resizes. */ act.sa_handler = handle_sigwinch; sigaction(SIGWINCH, &act, NULL); #endif /* Trap normal suspend (^Z) so we can handle it ourselves. */ if (!ISSET(SUSPEND)) { act.sa_handler = SIG_IGN; #ifdef SIGTSTP sigaction(SIGTSTP, &act, NULL); #endif } else { /* Block all other signals in the suspend and continue handlers. * If we don't do this, other stuff interrupts them! */ sigfillset(&act.sa_mask); act.sa_handler = do_suspend; #ifdef SIGTSTP sigaction(SIGTSTP, &act, NULL); #endif act.sa_handler = do_continue; #ifdef SIGCONT sigaction(SIGCONT, &act, NULL); #endif } } /* Handler for SIGHUP (hangup) and SIGTERM (terminate). */ RETSIGTYPE handle_hupterm(int signal) { die(_("Received SIGHUP or SIGTERM\n")); } /* Handler for SIGTSTP (suspend). */ RETSIGTYPE do_suspend(int signal) { #ifndef DISABLE_MOUSE /* Turn mouse support off. */ disable_mouse_support(); #endif /* Move the cursor to the last line of the screen. */ move(LINES - 1, 0); endwin(); /* Display our helpful message. */ printf(_("Use \"fg\" to return to nano.\n")); fflush(stdout); /* Restore the old terminal settings. */ tcsetattr(0, TCSANOW, &oldterm); /* Trap SIGHUP and SIGTERM so we can properly deal with them while * suspended. */ act.sa_handler = handle_hupterm; #ifdef SIGHUP sigaction(SIGHUP, &act, NULL); #endif sigaction(SIGTERM, &act, NULL); /* Do what mutt does: send ourselves a SIGSTOP. */ #ifdef SIGSTOP kill(0, SIGSTOP); #endif } /* The version of above function that is bound to a key. */ void do_suspend_void(void) { if (ISSET(SUSPEND)) do_suspend(0); else { statusbar(_("Suspension is not enabled")); beep(); } } /* Handler for SIGCONT (continue after suspend). */ RETSIGTYPE do_continue(int signal) { #ifndef DISABLE_MOUSE /* Turn mouse support back on if it was on before. */ if (ISSET(USE_MOUSE)) enable_mouse_support(); #endif #ifndef NANO_TINY /* Perhaps the user resized the window while we slept. So act as if, * and restore the terminal to its previous state in the process. */ regenerate_screen(); #else /* Restore the state of the terminal and redraw the whole screen. */ terminal_init(); total_refresh(); #endif } #ifndef NANO_TINY /* Handler for SIGWINCH (window size change). */ RETSIGTYPE handle_sigwinch(int signal) { /* Let the input routine know that a SIGWINCH has occurred. */ the_window_resized = TRUE; } /* Reinitialize and redraw the screen completely. */ void regenerate_screen(void) { const char *tty = ttyname(0); int fd, result = 0; struct winsize win; /* Reset the trigger. */ the_window_resized = FALSE; if (tty == NULL) return; fd = open(tty, O_RDWR); if (fd == -1) return; result = ioctl(fd, TIOCGWINSZ, &win); close(fd); if (result == -1) return; /* We could check whether the COLS or LINES changed, and return * otherwise. However, COLS and LINES are curses global variables, * and in some cases curses has already updated them. But not in * all cases. Argh. */ #ifdef REDEFINING_MACROS_OK COLS = win.ws_col; LINES = win.ws_row; #endif editwincols = COLS - margin; /* Ensure that firstcolumn is the starting column of its chunk. */ ensure_firstcolumn_is_aligned(); #ifdef USE_SLANG /* Slang curses emulation brain damage, part 1: If we just do what * curses does here, it'll only work properly if the resize made the * window smaller. Do what mutt does: Leave and immediately reenter * Slang screen management mode. */ SLsmg_reset_smg(); SLsmg_init_smg(); #else /* Do the equivalent of what Minimum Profit does: Leave and * immediately reenter curses mode. */ endwin(); doupdate(); #endif /* Restore the terminal to its previous state. */ terminal_init(); /* Do the equivalent of what both mutt and Minimum Profit do: * Reinitialize all the windows based on the new screen * dimensions. */ window_init(); /* Redraw the contents of the windows that need it. */ total_refresh(); } /* If allow is FALSE, block any SIGWINCH signal. If allow is TRUE, * unblock SIGWINCH so any pending ones can be dealt with. */ void allow_sigwinch(bool allow) { sigset_t winch; sigemptyset(&winch); sigaddset(&winch, SIGWINCH); sigprocmask(allow ? SIG_UNBLOCK : SIG_BLOCK, &winch, NULL); } #endif /* !NANO_TINY */ #ifndef NANO_TINY /* Handle the global toggle specified in flag. */ void do_toggle(int flag) { bool enabled; if (ISSET(RESTRICTED) && (flag == SUSPEND || flag == MULTIBUFFER || flag == BACKUP_FILE || flag == NO_COLOR_SYNTAX)) { show_restricted_warning(); return; } TOGGLE(flag); switch (flag) { #ifndef DISABLE_MOUSE case USE_MOUSE: mouse_init(); break; #endif case MORE_SPACE: case NO_HELP: window_init(); total_refresh(); break; case SUSPEND: signal_init(); break; case SOFTWRAP: if (!ISSET(SOFTWRAP)) openfile->firstcolumn = 0; refresh_needed = TRUE; break; case WHITESPACE_DISPLAY: titlebar(NULL); /* Fall through. */ #ifndef DISABLE_COLOR case NO_COLOR_SYNTAX: #endif refresh_needed = TRUE; break; } enabled = ISSET(flag); if (flag == NO_HELP || flag == NO_WRAP || flag == NO_COLOR_SYNTAX) enabled = !enabled; statusline(HUSH, "%s %s", _(flagtostr(flag)), enabled ? _("enabled") : _("disabled")); } /* Bleh. */ void do_toggle_void(void) { ; } #endif /* !NANO_TINY */ /* Disable extended input and output processing in our terminal * settings. */ void disable_extended_io(void) { #ifdef HAVE_TERMIOS_H struct termios term; tcgetattr(0, &term); term.c_lflag &= ~IEXTEN; term.c_oflag &= ~OPOST; tcsetattr(0, TCSANOW, &term); #endif } /* Disable interpretation of the special control keys in our terminal * settings. */ void disable_signals(void) { #ifdef HAVE_TERMIOS_H struct termios term; tcgetattr(0, &term); term.c_lflag &= ~ISIG; tcsetattr(0, TCSANOW, &term); #endif } #ifndef NANO_TINY /* Enable interpretation of the special control keys in our terminal * settings. */ void enable_signals(void) { #ifdef HAVE_TERMIOS_H struct termios term; tcgetattr(0, &term); term.c_lflag |= ISIG; tcsetattr(0, TCSANOW, &term); #endif } #endif /* Disable interpretation of the flow control characters in our terminal * settings. */ void disable_flow_control(void) { #ifdef HAVE_TERMIOS_H struct termios term; tcgetattr(0, &term); term.c_iflag &= ~IXON; tcsetattr(0, TCSANOW, &term); #endif } /* Enable interpretation of the flow control characters in our terminal * settings. */ void enable_flow_control(void) { #ifdef HAVE_TERMIOS_H struct termios term; tcgetattr(0, &term); term.c_iflag |= IXON; tcsetattr(0, TCSANOW, &term); #endif } /* Set up the terminal state. Put the terminal in raw mode (read one * character at a time, disable the special control keys, and disable * the flow control characters), disable translation of carriage return * (^M) into newline (^J) so that we can tell the difference between the * Enter key and Ctrl-J, and disable echoing of characters as they're * typed. Finally, disable extended input and output processing, and, * if we're not in preserve mode, reenable interpretation of the flow * control characters. */ void terminal_init(void) { #ifdef USE_SLANG /* Slang curses emulation brain damage, part 2: Slang doesn't * implement raw(), nonl(), or noecho() properly, so there's no way * to properly reinitialize the terminal using them. We have to * disable the special control keys and interpretation of the flow * control characters using termios, save the terminal state after * the first call, and restore it on subsequent calls. */ static struct termios newterm; static bool newterm_set = FALSE; if (!newterm_set) { #endif raw(); nonl(); noecho(); disable_extended_io(); if (ISSET(PRESERVE)) enable_flow_control(); disable_signals(); #ifdef USE_SLANG if (!ISSET(PRESERVE)) disable_flow_control(); tcgetattr(0, &newterm); newterm_set = TRUE; } else tcsetattr(0, TCSANOW, &newterm); #endif } /* Ask ncurses for a keycode, or assign a default one. */ int get_keycode(const char *keyname, const int standard) { #ifdef HAVE_KEY_DEFINED const char *keyvalue = tigetstr(keyname); if (keyvalue != 0 && keyvalue != (char *)-1) return key_defined(keyvalue); else #endif return standard; } /* Say that an unbound key was struck, and if possible which one. */ void unbound_key(int code) { if (!is_byte(code)) statusline(ALERT, _("Unbound key")); else if (meta_key) { if (code == '[') statusline(ALERT, _("Unbindable key: M-[")); else statusline(ALERT, _("Unbound key: M-%c"), toupper(code)); } else if (code < 0x20) statusline(ALERT, _("Unbound key: ^%c"), code + 0x40); else statusline(ALERT, _("Unbound key: %c"), code); } /* Read in a keystroke. Act on the keystroke if it is a shortcut or a toggle; * otherwise, insert it into the edit buffer. If allow_funcs is FALSE, don't * do anything with the keystroke -- just return it. */ int do_input(bool allow_funcs) { int input; /* The keystroke we read in: a character or a shortcut. */ static char *puddle = NULL; /* The input buffer for actual characters. */ static size_t depth = 0; /* The length of the input buffer. */ bool preserve = FALSE; /* Whether to preserve the contents of the cutbuffer. */ const sc *s; bool have_shortcut; /* Read in a keystroke. */ input = get_kbinput(edit); #ifndef NANO_TINY if (input == KEY_WINCH) return KEY_WINCH; #endif #ifndef DISABLE_MOUSE if (input == KEY_MOUSE) { /* We received a mouse click. */ if (do_mouse() == 1) /* The click was on a shortcut -- read in the character * that it was converted into. */ input = get_kbinput(edit); else /* The click was invalid or has been handled -- get out. */ return ERR; } #endif /* Check for a shortcut in the main list. */ s = get_shortcut(&input); /* If we got a shortcut from the main list, or a "universal" * edit window shortcut, set have_shortcut to TRUE. */ have_shortcut = (s != NULL); /* If we got a non-high-bit control key, a meta key sequence, or a * function key, and it's not a shortcut or toggle, throw it out. */ if (!have_shortcut) { if (is_ascii_cntrl_char(input) || meta_key || !is_byte(input)) { unbound_key(input); input = ERR; } } if (!allow_funcs) return input; /* If the keystroke isn't a shortcut nor a toggle, it's a normal text * character: add the character to the input buffer -- or display a * warning when we're in view mode. */ if (input != ERR && !have_shortcut) { if (ISSET(VIEW_MODE)) print_view_warning(); else { /* Store the byte, and leave room for a terminating zero. */ puddle = charealloc(puddle, depth + 2); puddle[depth++] = (char)input; } #ifndef NANO_TINY if (openfile->mark_set && openfile->kind_of_mark == SOFTMARK) { openfile->mark_set = FALSE; refresh_needed = TRUE; } #endif } /* If we got a shortcut or toggle, or if there aren't any other * characters waiting after the one we read in, we need to output * all available characters in the input puddle. Note that this * puddle will be empty if we're in view mode. */ if (have_shortcut || get_key_buffer_len() == 0) { #ifndef DISABLE_WRAPPING /* If we got a shortcut or toggle, and it's not the shortcut * for verbatim input, turn off prepending of wrapped text. */ if (have_shortcut && s->scfunc != do_verbatim_input) wrap_reset(); #endif if (puddle != NULL) { /* Insert all bytes in the input buffer into the edit buffer * at once, filtering out any low control codes. */ puddle[depth] = '\0'; do_output(puddle, depth, FALSE); /* Empty the input buffer. */ free(puddle); puddle = NULL; depth = 0; } } if (!have_shortcut) pletion_line = NULL; else { const subnfunc *f = sctofunc(s); if (ISSET(VIEW_MODE) && f && !f->viewok) { print_view_warning(); return ERR; } /* If the function associated with this shortcut is * cutting or copying text, remember this. */ if (s->scfunc == do_cut_text_void #ifndef NANO_TINY || s->scfunc == do_copy_text || s->scfunc == do_cut_till_eof #endif ) preserve = TRUE; #ifdef ENABLE_WORDCOMPLETION if (s->scfunc != complete_a_word) pletion_line = NULL; #endif #ifndef NANO_TINY if (s->scfunc == do_toggle_void) { do_toggle(s->toggle); if (s->toggle != CUT_TO_END) preserve = TRUE; } else #endif { #ifndef NANO_TINY /* If Shifted movement occurs, set the mark. */ if (shift_held && !openfile->mark_set) { openfile->mark_set = TRUE; openfile->mark_begin = openfile->current; openfile->mark_begin_x = openfile->current_x; openfile->kind_of_mark = SOFTMARK; } #endif /* Execute the function of the shortcut. */ s->scfunc(); #ifndef NANO_TINY /* If Shiftless movement occurred, discard a soft mark. */ if (openfile->mark_set && !shift_held && openfile->kind_of_mark == SOFTMARK) { openfile->mark_set = FALSE; openfile->mark_begin = NULL; refresh_needed = TRUE; } #endif #ifndef DISABLE_COLOR if (f && !f->viewok) check_the_multis(openfile->current); #endif if (!refresh_needed && (s->scfunc == do_delete || s->scfunc == do_backspace)) update_line(openfile->current, openfile->current_x); } } /* If we aren't cutting or copying text, and the key wasn't a toggle, * blow away the text in the cutbuffer upon the next cutting action. */ if (!preserve) cutbuffer_reset(); return input; } void xon_complaint(void) { statusbar(_("XON ignored, mumble mumble")); } void xoff_complaint(void) { statusbar(_("XOFF ignored, mumble mumble")); } #ifndef DISABLE_MOUSE /* Handle a mouse click on the edit window or the shortcut list. */ int do_mouse(void) { int mouse_col, mouse_row; int retval = get_mouseinput(&mouse_col, &mouse_row, TRUE); /* If the click is wrong or already handled, we're done. */ if (retval != 0) return retval; /* If the click was in the edit window, put the cursor in that spot. */ if (wmouse_trafo(edit, &mouse_row, &mouse_col, FALSE)) { bool sameline = (mouse_row == openfile->current_y); /* Whether the click was on the row where the cursor is. */ filestruct *current_save = openfile->current; ssize_t row_count = mouse_row - openfile->current_y; size_t leftedge; #ifndef NANO_TINY size_t current_x_save = openfile->current_x; if (ISSET(SOFTWRAP)) leftedge = (xplustabs() / editwincols) * editwincols; else #endif leftedge = get_page_start(xplustabs()); #ifdef DEBUG fprintf(stderr, "mouse_row = %d, current_y = %ld\n", mouse_row, (long)openfile->current_y); #endif /* Move current up or down to the row corresponding to mouse_row. */ if (row_count < 0) go_back_chunks(-row_count, &openfile->current, &leftedge); else go_forward_chunks(row_count, &openfile->current, &leftedge); openfile->current_x = actual_x(openfile->current->data, leftedge + mouse_col); #ifndef NANO_TINY /* Clicking where the cursor is toggles the mark, as does clicking * beyond the line length with the cursor at the end of the line. */ if (sameline && openfile->current_x == current_x_save) do_mark(); else #endif /* The cursor moved; clean the cutbuffer on the next cut. */ cutbuffer_reset(); edit_redraw(current_save); } /* No more handling is needed. */ return 2; } #endif /* !DISABLE_MOUSE */ /* The user typed output_len multibyte characters. Add them to the edit * buffer, filtering out all ASCII control characters if allow_cntrls is * TRUE. */ void do_output(char *output, size_t output_len, bool allow_cntrls) { size_t current_len, i = 0; #ifndef NANO_TINY size_t orig_rows = 0, original_row = 0; #endif char *char_buf = charalloc(mb_cur_max()); int char_len; current_len = strlen(openfile->current->data); #ifndef NANO_TINY if (ISSET(SOFTWRAP)) { if (openfile->current_y == editwinrows - 1) original_row = xplustabs() / editwincols; orig_rows = strlenpt(openfile->current->data) / editwincols; } #endif while (i < output_len) { /* Encode an embedded NUL byte as 0x0A. */ if (output[i] == '\0') output[i] = '\n'; /* Get the next multibyte character. */ char_len = parse_mbchar(output + i, char_buf, NULL); i += char_len; /* If controls are not allowed, ignore an ASCII control character. */ if (!allow_cntrls && is_ascii_cntrl_char(*(output + i - char_len))) continue; /* If we're adding to the magicline, create a new magicline. */ if (!ISSET(NO_NEWLINES) && openfile->filebot == openfile->current) { new_magicline(); if (margin > 0) refresh_needed = TRUE; } assert(openfile->current_x <= current_len); /* Make room for the new character and copy it into the line. */ openfile->current->data = charealloc(openfile->current->data, current_len + char_len + 1); charmove(openfile->current->data + openfile->current_x + char_len, openfile->current->data + openfile->current_x, current_len - openfile->current_x + 1); strncpy(openfile->current->data + openfile->current_x, char_buf, char_len); current_len += char_len; openfile->totsize++; set_modified(); #ifndef NANO_TINY add_undo(ADD); /* Note that current_x has not yet been incremented. */ if (openfile->mark_set && openfile->current == openfile->mark_begin && openfile->current_x < openfile->mark_begin_x) openfile->mark_begin_x += char_len; #endif openfile->current_x += char_len; #ifndef NANO_TINY update_undo(ADD); #endif #ifndef DISABLE_WRAPPING /* If text gets wrapped, the edit window needs a refresh. */ if (!ISSET(NO_WRAP) && do_wrap(openfile->current)) refresh_needed = TRUE; #endif } #ifndef NANO_TINY /* If the number of screen rows that a softwrapped line occupies has * changed, we need a full refresh. And if we were on the last line * of the edit window, and we moved one screen row, we're now below * the last line of the edit window, so we need a full refresh too. */ if (ISSET(SOFTWRAP) && refresh_needed == FALSE) if ((strlenpt(openfile->current->data) / editwincols) != orig_rows || (openfile->current_y == editwinrows - 1 && xplustabs() / editwincols != original_row)) refresh_needed = TRUE; #endif free(char_buf); openfile->placewewant = xplustabs(); #ifndef DISABLE_COLOR check_the_multis(openfile->current); #endif if (!refresh_needed) update_line(openfile->current, openfile->current_x); } int main(int argc, char **argv) { int optchr; ssize_t startline = 0, startcol = 0; /* Target line and column when specified on the command line. */ #ifndef DISABLE_WRAPJUSTIFY bool fill_used = FALSE; /* Was the fill option used on the command line? */ #ifndef DISABLE_WRAPPING bool forced_wrapping = FALSE; /* Should long lines be automatically hard wrapped? */ #endif #endif #ifndef DISABLE_MULTIBUFFER bool old_multibuffer; /* The old value of the multibuffer option, restored after we * load all files on the command line. */ #endif const struct option long_options[] = { {"boldtext", 0, NULL, 'D'}, #ifndef DISABLE_MULTIBUFFER {"multibuffer", 0, NULL, 'F'}, #endif #ifndef DISABLE_NANORC {"ignorercfiles", 0, NULL, 'I'}, #endif {"rebindkeypad", 0, NULL, 'K'}, {"nonewlines", 0, NULL, 'L'}, {"morespace", 0, NULL, 'O'}, #ifndef DISABLE_JUSTIFY {"quotestr", 1, NULL, 'Q'}, #endif {"restricted", 0, NULL, 'R'}, {"tabsize", 1, NULL, 'T'}, {"version", 0, NULL, 'V'}, #ifndef DISABLE_COLOR {"syntax", 1, NULL, 'Y'}, #endif {"constantshow", 0, NULL, 'c'}, {"rebinddelete", 0, NULL, 'd'}, #ifndef DISABLE_BROWSER {"showcursor", 0, NULL, 'g'}, #endif {"help", 0, NULL, 'h'}, #ifdef ENABLE_LINENUMBERS {"linenumbers", 0, NULL, 'l'}, #endif #ifndef DISABLE_MOUSE {"mouse", 0, NULL, 'm'}, #endif {"noread", 0, NULL, 'n'}, #ifndef DISABLE_OPERATINGDIR {"operatingdir", 1, NULL, 'o'}, #endif {"preserve", 0, NULL, 'p'}, {"quiet", 0, NULL, 'q'}, #ifndef DISABLE_WRAPJUSTIFY {"fill", 1, NULL, 'r'}, #endif #ifndef DISABLE_SPELLER {"speller", 1, NULL, 's'}, #endif {"tempfile", 0, NULL, 't'}, {"view", 0, NULL, 'v'}, #ifndef DISABLE_WRAPPING {"nowrap", 0, NULL, 'w'}, #endif {"nohelp", 0, NULL, 'x'}, {"suspend", 0, NULL, 'z'}, #ifndef NANO_TINY {"smarthome", 0, NULL, 'A'}, {"backup", 0, NULL, 'B'}, {"backupdir", 1, NULL, 'C'}, {"tabstospaces", 0, NULL, 'E'}, {"locking", 0, NULL, 'G'}, {"historylog", 0, NULL, 'H'}, {"noconvert", 0, NULL, 'N'}, {"poslog", 0, NULL, 'P'}, /* deprecated form, remove in 2018 */ {"positionlog", 0, NULL, 'P'}, {"smooth", 0, NULL, 'S'}, {"quickblank", 0, NULL, 'U'}, {"wordbounds", 0, NULL, 'W'}, {"wordchars", 1, NULL, 'X'}, {"autoindent", 0, NULL, 'i'}, {"cut", 0, NULL, 'k'}, {"unix", 0, NULL, 'u'}, {"softwrap", 0, NULL, '$'}, #endif {NULL, 0, NULL, 0} }; /* Back up the terminal settings so that they can be restored. */ tcgetattr(0, &oldterm); #ifdef ENABLE_UTF8 { /* If the locale set exists and uses UTF-8, we should use * UTF-8. */ char *locale = setlocale(LC_ALL, ""); if (locale != NULL && (strcmp(nl_langinfo(CODESET), "UTF-8") == 0)) { #ifdef USE_SLANG SLutf8_enable(1); #endif utf8_init(); } } #else setlocale(LC_ALL, ""); #endif #ifdef ENABLE_NLS bindtextdomain(PACKAGE, LOCALEDIR); textdomain(PACKAGE); #endif #if defined(DISABLE_NANORC) && defined(DISABLE_ROOTWRAPPING) /* If we don't have rcfile support, --disable-wrapping-as-root is * used, and we're root, turn wrapping off. */ if (geteuid() == NANO_ROOT_UID) SET(NO_WRAP); #endif /* If the executable's name starts with 'r', activate restricted mode. */ if (*(tail(argv[0])) == 'r') SET(RESTRICTED); while ((optchr = getopt_long(argc, argv, "ABC:DEFGHIKLNOPQ:RST:UVWX:Y:abcdefghijklmno:pqr:s:tuvwxz$", long_options, NULL)) != -1) { switch (optchr) { case 'a': case 'b': case 'e': case 'f': case 'j': /* Pico compatibility flags. */ break; #ifndef NANO_TINY case 'A': SET(SMART_HOME); break; case 'B': SET(BACKUP_FILE); break; case 'C': backup_dir = mallocstrcpy(backup_dir, optarg); break; #endif case 'D': SET(BOLD_TEXT); break; #ifndef NANO_TINY case 'E': SET(TABS_TO_SPACES); break; #endif #ifndef DISABLE_MULTIBUFFER case 'F': SET(MULTIBUFFER); break; #endif #ifndef NANO_TINY case 'G': SET(LOCKING); break; #endif #ifndef DISABLE_HISTORIES case 'H': SET(HISTORYLOG); break; #endif #ifndef DISABLE_NANORC case 'I': no_rcfiles = TRUE; break; #endif case 'K': SET(REBIND_KEYPAD); break; case 'L': SET(NO_NEWLINES); break; #ifndef NANO_TINY case 'N': SET(NO_CONVERT); break; #endif case 'O': SET(MORE_SPACE); break; #ifndef DISABLE_HISTORIES case 'P': SET(POS_HISTORY); break; #endif #ifndef DISABLE_JUSTIFY case 'Q': quotestr = mallocstrcpy(quotestr, optarg); break; #endif case 'R': SET(RESTRICTED); break; #ifndef NANO_TINY case 'S': SET(SMOOTH_SCROLL); break; #endif case 'T': if (!parse_num(optarg, &tabsize) || tabsize <= 0) { fprintf(stderr, _("Requested tab size \"%s\" is invalid"), optarg); fprintf(stderr, "\n"); exit(1); } break; #ifndef NANO_TINY case 'U': SET(QUICK_BLANK); break; #endif case 'V': version(); exit(0); #ifndef NANO_TINY case 'W': SET(WORD_BOUNDS); break; case 'X': word_chars = mallocstrcpy(word_chars, optarg); break; #endif #ifndef DISABLE_COLOR case 'Y': syntaxstr = mallocstrcpy(syntaxstr, optarg); break; #endif case 'c': SET(CONST_UPDATE); break; case 'd': SET(REBIND_DELETE); break; case 'g': SET(SHOW_CURSOR); break; #ifndef NANO_TINY case 'i': SET(AUTOINDENT); break; case 'k': SET(CUT_TO_END); break; #endif #ifndef DISABLE_MOUSE case 'm': SET(USE_MOUSE); break; #endif case 'n': SET(NOREAD_MODE); break; #ifndef DISABLE_OPERATINGDIR case 'o': operating_dir = mallocstrcpy(operating_dir, optarg); break; #endif case 'p': SET(PRESERVE); break; #ifndef DISABLE_NANORC case 'q': SET(QUIET); break; #endif #ifndef DISABLE_WRAPJUSTIFY case 'r': if (!parse_num(optarg, &wrap_at)) { fprintf(stderr, _("Requested fill size \"%s\" is invalid"), optarg); fprintf(stderr, "\n"); exit(1); } fill_used = TRUE; #ifndef DISABLE_WRAPPING forced_wrapping = TRUE; #endif break; #endif #ifndef DISABLE_SPELLER case 's': alt_speller = mallocstrcpy(alt_speller, optarg); break; #endif case 't': SET(TEMP_FILE); break; #ifndef NANO_TINY case 'u': SET(MAKE_IT_UNIX); break; #endif case 'v': SET(VIEW_MODE); break; #ifndef DISABLE_WRAPPING case 'w': SET(NO_WRAP); /* If both --fill and --nowrap are given on the * command line, the last given option wins. */ forced_wrapping = FALSE; break; #endif case 'x': SET(NO_HELP); break; case 'z': SET(SUSPEND); break; #ifndef NANO_TINY case '$': SET(SOFTWRAP); break; #endif #ifdef ENABLE_LINENUMBERS case 'l': SET(LINE_NUMBERS); break; #endif case 'h': usage(); exit(0); default: printf(_("Type '%s -h' for a list of available options.\n"), argv[0]); exit(1); } } /* If we're using restricted mode, disable suspending, backups, * rcfiles, and history files, since they all would allow reading * from or writing to files not specified on the command line. */ if (ISSET(RESTRICTED)) { UNSET(SUSPEND); UNSET(BACKUP_FILE); #ifndef DISABLE_NANORC no_rcfiles = TRUE; UNSET(HISTORYLOG); UNSET(POS_HISTORY); #endif } /* Set up the function and shortcut lists. This needs to be done * before reading the rcfile, to be able to rebind/unbind keys. */ shortcut_init(); /* We've read through the command line options. Now back up the flags * and values that are set, and read the rcfile(s). If the values * haven't changed afterward, restore the backed-up values. */ #ifndef DISABLE_NANORC if (!no_rcfiles) { #ifndef DISABLE_OPERATINGDIR char *operating_dir_cpy = operating_dir; #endif #ifndef DISABLE_WRAPJUSTIFY ssize_t wrap_at_cpy = wrap_at; #endif #ifndef NANO_TINY char *backup_dir_cpy = backup_dir; char *word_chars_cpy = word_chars; #endif #ifndef DISABLE_JUSTIFY char *quotestr_cpy = quotestr; #endif #ifndef DISABLE_SPELLER char *alt_speller_cpy = alt_speller; #endif ssize_t tabsize_cpy = tabsize; unsigned flags_cpy[sizeof(flags) / sizeof(flags[0])]; size_t i; memcpy(flags_cpy, flags, sizeof(flags_cpy)); #ifndef DISABLE_OPERATINGDIR operating_dir = NULL; #endif #ifndef NANO_TINY backup_dir = NULL; word_chars = NULL; #endif #ifndef DISABLE_JUSTIFY quotestr = NULL; #endif #ifndef DISABLE_SPELLER alt_speller = NULL; #endif do_rcfiles(); #ifdef DEBUG fprintf(stderr, "After rebinding keys...\n"); print_sclist(); #endif #ifndef DISABLE_OPERATINGDIR if (operating_dir_cpy != NULL) { free(operating_dir); operating_dir = operating_dir_cpy; } #endif #ifndef DISABLE_WRAPJUSTIFY if (fill_used) wrap_at = wrap_at_cpy; #endif #ifndef NANO_TINY if (backup_dir_cpy != NULL) { free(backup_dir); backup_dir = backup_dir_cpy; } if (word_chars_cpy != NULL) { free(word_chars); word_chars = word_chars_cpy; } #endif #ifndef DISABLE_JUSTIFY if (quotestr_cpy != NULL) { free(quotestr); quotestr = quotestr_cpy; } #endif #ifndef DISABLE_SPELLER if (alt_speller_cpy != NULL) { free(alt_speller); alt_speller = alt_speller_cpy; } #endif if (tabsize_cpy != -1) tabsize = tabsize_cpy; for (i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) flags[i] |= flags_cpy[i]; } #ifdef DISABLE_ROOTWRAPPING /* If we don't have any rcfiles, --disable-wrapping-as-root is used, * and we're root, turn wrapping off. */ else if (geteuid() == NANO_ROOT_UID) SET(NO_WRAP); #endif #endif /* !DISABLE_NANORC */ #ifndef DISABLE_WRAPPING /* Override a "set nowrap" in an rcfile (or a --disable-wrapping-as-root) * if --fill was given on the command line and not undone by --nowrap. */ if (forced_wrapping) UNSET(NO_WRAP); #endif /* If we're using bold text instead of reverse video text, set it up * now. */ if (ISSET(BOLD_TEXT)) hilite_attribute = A_BOLD; #ifndef DISABLE_HISTORIES /* Set up the search/replace history. */ history_init(); /* Verify that the home directory and ~/.nano subdir exist. */ if (ISSET(HISTORYLOG) || ISSET(POS_HISTORY)) { get_homedir(); if (homedir == NULL || check_dotnano() == 0) { UNSET(HISTORYLOG); UNSET(POS_HISTORY); } } if (ISSET(HISTORYLOG)) load_history(); if (ISSET(POS_HISTORY)) load_poshistory(); #endif /* !DISABLE_HISTORIES */ #ifndef NANO_TINY /* Set up the backup directory (unless we're using restricted mode, * in which case backups are disabled, since they would allow * reading from or writing to files not specified on the command * line). This entails making sure it exists and is a directory, so * that backup files will be saved there. */ if (!ISSET(RESTRICTED)) init_backup_dir(); #endif #ifndef DISABLE_OPERATINGDIR /* Set up the operating directory. This entails chdir()ing there, * so that file reads and writes will be based there. */ init_operating_dir(); #endif #ifndef DISABLE_JUSTIFY /* If punct wasn't specified, set its default value. */ if (punct == NULL) punct = mallocstrcpy(NULL, "!.?"); /* If brackets wasn't specified, set its default value. */ if (brackets == NULL) brackets = mallocstrcpy(NULL, "\"')>]}"); /* If quotestr wasn't specified, set its default value. */ if (quotestr == NULL) quotestr = mallocstrcpy(NULL, "^([ \t]*[#:>|}])+"); quoterc = regcomp("ereg, quotestr, NANO_REG_EXTENDED); if (quoterc == 0) { /* We no longer need quotestr, just quotereg. */ free(quotestr); quotestr = NULL; } else { size_t size = regerror(quoterc, "ereg, NULL, 0); quoteerr = charalloc(size); regerror(quoterc, "ereg, quoteerr, size); } #endif /* !DISABLE_JUSTIFY */ #ifndef DISABLE_SPELLER /* If we don't have an alternative spell checker after reading the * command line and/or rcfile(s), check $SPELL for one, as Pico * does (unless we're using restricted mode, in which case spell * checking is disabled, since it would allow reading from or * writing to files not specified on the command line). */ if (!ISSET(RESTRICTED) && alt_speller == NULL) { char *spellenv = getenv("SPELL"); if (spellenv != NULL) alt_speller = mallocstrcpy(NULL, spellenv); } #endif #ifndef NANO_TINY /* If matchbrackets wasn't specified, set its default value. */ if (matchbrackets == NULL) matchbrackets = mallocstrcpy(NULL, "(<[{)>]}"); /* If whitespace wasn't specified, set its default value. If we're * using UTF-8, it's Unicode 00BB (Right-Pointing Double Angle * Quotation Mark) and Unicode 00B7 (Middle Dot). Otherwise, it's * ">" and ".". */ if (whitespace == NULL) { #ifdef ENABLE_UTF8 if (using_utf8()) { whitespace = mallocstrcpy(NULL, "\xC2\xBB\xC2\xB7"); whitespace_len[0] = 2; whitespace_len[1] = 2; } else #endif { whitespace = mallocstrcpy(NULL, ">."); whitespace_len[0] = 1; whitespace_len[1] = 1; } } #endif /* !NANO_TINY */ /* Initialize the search string. */ last_search = mallocstrcpy(NULL, ""); /* If tabsize wasn't specified, set its default value. */ if (tabsize == -1) tabsize = WIDTH_OF_TAB; /* Initialize curses mode. If this fails, get out. */ if (initscr() == NULL) exit(1); /* Set up the terminal state. */ terminal_init(); #ifdef __linux__ /* Check whether we're running on a Linux console. */ console = (getenv("DISPLAY") == NULL); #endif #ifdef DEBUG fprintf(stderr, "Main: set up windows\n"); #endif /* Initialize all the windows based on the current screen * dimensions. */ window_init(); editwincols = COLS; /* Set up the signal handlers. */ signal_init(); #ifndef DISABLE_MOUSE /* Initialize mouse support. */ mouse_init(); #endif #ifndef DISABLE_COLOR set_colorpairs(); #else interface_color_pair[TITLE_BAR] = hilite_attribute; interface_color_pair[LINE_NUMBER] = hilite_attribute; interface_color_pair[STATUS_BAR] = hilite_attribute; interface_color_pair[KEY_COMBO] = hilite_attribute; interface_color_pair[FUNCTION_TAG] = A_NORMAL; #endif /* Ask ncurses for the key codes for Control+Left/Right/Up/Down. */ controlleft = get_keycode("kLFT5", CONTROL_LEFT); controlright = get_keycode("kRIT5", CONTROL_RIGHT); controlup = get_keycode("kUP5", CONTROL_UP); controldown = get_keycode("kDN5", CONTROL_DOWN); #ifndef NANO_TINY /* Ask for the codes for Shift+Control+Left/Right/Up/Down. */ shiftcontrolleft = get_keycode("kLFT6", SHIFT_CONTROL_LEFT); shiftcontrolright = get_keycode("kRIT6", SHIFT_CONTROL_RIGHT); shiftcontrolup = get_keycode("kUP6", SHIFT_CONTROL_UP); shiftcontroldown = get_keycode("kDN6", SHIFT_CONTROL_DOWN); /* Ask for the codes for Shift+Alt+Left/Right/Up/Down. */ shiftaltleft = get_keycode("kLFT4", SHIFT_ALT_LEFT); shiftaltright = get_keycode("kRIT4", SHIFT_ALT_RIGHT); shiftaltup = get_keycode("kUP4", SHIFT_ALT_UP); shiftaltdown = get_keycode("kDN4", SHIFT_ALT_DOWN); #endif #ifdef HAVE_SET_ESCDELAY /* Tell ncurses to pass the Esc key quickly. */ set_escdelay(50); #endif #ifdef DEBUG fprintf(stderr, "Main: open file\n"); #endif /* If there's a +LINE or +LINE,COLUMN flag here, it is the first * non-option argument, and it is followed by at least one other * argument, the filename it applies to. */ if (0 < optind && optind < argc - 1 && argv[optind][0] == '+') { if (!parse_line_column(&argv[optind][1], &startline, &startcol)) statusline(ALERT, _("Invalid line or column number")); optind++; } /* If one of the arguments is a dash, read text from standard input. */ if (optind < argc && !strcmp(argv[optind], "-")) { stdin_pager(); set_modified(); optind++; } #ifndef DISABLE_MULTIBUFFER old_multibuffer = ISSET(MULTIBUFFER); SET(MULTIBUFFER); /* Read all the files after the first one on the command line into * new buffers. */ { int i = optind + 1; ssize_t iline = 0, icol = 0; for (; i < argc; i++) { /* If there's a +LINE or +LINE,COLUMN flag here, it is followed * by at least one other argument: the filename it applies to. */ if (i < argc - 1 && argv[i][0] == '+') { if (!parse_line_column(&argv[i][1], &iline, &icol)) statusline(ALERT, _("Invalid line or column number")); } else { /* If opening fails, don't try to position the cursor. */ if (!open_buffer(argv[i], FALSE)) continue; /* If a position was given on the command line, go there. */ if (iline > 0 || icol > 0) { do_gotolinecolumn(iline, icol, FALSE, FALSE); iline = 0; icol = 0; } #ifndef DISABLE_HISTORIES else if (ISSET(POS_HISTORY)) { ssize_t savedposline, savedposcol; /* If edited before, restore the last cursor position. */ if (has_old_position(argv[i], &savedposline, &savedposcol)) do_gotolinecolumn(savedposline, savedposcol, FALSE, FALSE); } #endif } } } #endif /* !DISABLE_MULTIBUFFER */ /* Now read the first file on the command line into a new buffer. */ if (optind < argc) open_buffer(argv[optind], FALSE); /* If all the command-line arguments were invalid files like directories, * or if there were no filenames given, we didn't open any file. In this * case, load a blank buffer. Also, unset view mode to allow editing. */ if (openfile == NULL) { open_buffer("", FALSE); UNSET(VIEW_MODE); } #ifndef DISABLE_MULTIBUFFER if (!old_multibuffer) UNSET(MULTIBUFFER); #endif /* If a starting position was given on the command line, go there. */ if (startline > 0 || startcol > 0) do_gotolinecolumn(startline, startcol, FALSE, FALSE); #ifndef DISABLE_HISTORIES else if (ISSET(POS_HISTORY)) { ssize_t savedposline, savedposcol; /* If the file was edited before, restore the last cursor position. */ if (has_old_position(argv[optind], &savedposline, &savedposcol)) do_gotolinecolumn(savedposline, savedposcol, FALSE, FALSE); } #endif #ifdef DEBUG fprintf(stderr, "Main: show buffer contents, and enter main loop\n"); #endif display_buffer(); while (TRUE) { #ifdef ENABLE_LINENUMBERS int needed_margin = digits(openfile->filebot->lineno) + 1; /* Only enable line numbers when there is enough room for them. */ if (!ISSET(LINE_NUMBERS) || needed_margin > COLS - 4) needed_margin = 0; if (needed_margin != margin) { margin = needed_margin; editwincols = COLS - margin; /* Ensure that firstcolumn is the starting column of its chunk. */ ensure_firstcolumn_is_aligned(); /* The margin has changed -- schedule a full refresh. */ refresh_needed = TRUE; } #endif if (currmenu != MMAIN) display_main_list(); lastmessage = HUSH; as_an_at = TRUE; /* Update the displayed current cursor position only when there * are no keys waiting in the input buffer. */ if (ISSET(CONST_UPDATE) && get_key_buffer_len() == 0) do_cursorpos(FALSE); /* Refresh just the cursor position or the entire edit window. */ if (!refresh_needed) { reset_cursor(); wnoutrefresh(edit); } else edit_refresh(); /* Make sure the cursor is visible. */ curs_set(1); focusing = TRUE; /* Forget any earlier statusbar x position. */ reinit_statusbar_x(); /* Read in and interpret keystrokes. */ do_input(TRUE); } /* We should never get here. */ assert(FALSE); }