Imported Upstream version 2.3.1upstream/2.3.1upstream

19 files changed, 25230 insertions, 0 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
new file mode 100644
index 0000000..f0b21c0
--- /dev/null
+++ b/src/Makefile.am
@@ -0,0 +1,30 @@
+localedir = $(datadir)/locale
+INCLUDES = -DLOCALEDIR=\"$(localedir)\" -DSYSCONFDIR=\"$(sysconfdir)\"
+
+ACLOCAL_AMFLAGS = -I m4
+
+bin_PROGRAMS = 	nano
+nano_SOURCES =	browser.c \
+		chars.c \
+		color.c \
+		cut.c \
+		files.c \
+		global.c \
+		help.c \
+		move.c \
+		nano.c \
+		nano.h \
+		prompt.c \
+		proto.h \
+		rcfile.c \
+		search.c \
+		text.c \
+		utils.c \
+		winio.c 
+
+nano_LDADD = @GLIB_LIBS@ @LIBINTL@
+
+install-exec-hook:
+	cd $(DESTDIR)$(bindir) && rm -f rnano && $(LN_S) nano rnano
+uninstall-hook:
+	cd $(DESTDIR)$(bindir) && rm -f rnano
diff --git a/src/Makefile.in b/src/Makefile.in
new file mode 100644
index 0000000..acb3389
--- /dev/null
+++ b/src/Makefile.in
@@ -0,0 +1,536 @@
+# Makefile.in generated by automake 1.11.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005, 2006, 2007, 2008, 2009  Free Software Foundation,
+# Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+VPATH = @srcdir@
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+target_triplet = @target@
+bin_PROGRAMS = nano$(EXEEXT)
+subdir = src
+DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_define_dir.m4 \
+	$(top_srcdir)/m4/gettext.m4 $(top_srcdir)/m4/glib-2.0.m4 \
+	$(top_srcdir)/m4/iconv.m4 $(top_srcdir)/m4/isc-posix.m4 \
+	$(top_srcdir)/m4/lib-ld.m4 $(top_srcdir)/m4/lib-link.m4 \
+	$(top_srcdir)/m4/lib-prefix.m4 $(top_srcdir)/m4/progtest.m4 \
+	$(top_srcdir)/configure.ac
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+	$(ACLOCAL_M4)
+mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__installdirs = "$(DESTDIR)$(bindir)"
+PROGRAMS = $(bin_PROGRAMS)
+am_nano_OBJECTS = browser.$(OBJEXT) chars.$(OBJEXT) color.$(OBJEXT) \
+	cut.$(OBJEXT) files.$(OBJEXT) global.$(OBJEXT) help.$(OBJEXT) \
+	move.$(OBJEXT) nano.$(OBJEXT) prompt.$(OBJEXT) \
+	rcfile.$(OBJEXT) search.$(OBJEXT) text.$(OBJEXT) \
+	utils.$(OBJEXT) winio.$(OBJEXT)
+nano_OBJECTS = $(am_nano_OBJECTS)
+nano_DEPENDENCIES =
+DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+CCLD = $(CC)
+LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+SOURCES = $(nano_SOURCES)
+DIST_SOURCES = $(nano_SOURCES)
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+AMTAR = @AMTAR@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CURSES_LIB = @CURSES_LIB@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+EGREP = @EGREP@
+EXEEXT = @EXEEXT@
+GLIB_CFLAGS = @GLIB_CFLAGS@
+GLIB_GENMARSHAL = @GLIB_GENMARSHAL@
+GLIB_LIBS = @GLIB_LIBS@
+GLIB_MKENUMS = @GLIB_MKENUMS@
+GMSGFMT = @GMSGFMT@
+GOBJECT_QUERY = @GOBJECT_QUERY@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+INTLLIBS = @INTLLIBS@
+LDFLAGS = @LDFLAGS@
+LIBICONV = @LIBICONV@
+LIBINTL = @LIBINTL@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LN_S = @LN_S@
+LTLIBICONV = @LTLIBICONV@
+LTLIBINTL = @LTLIBINTL@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MKDIR_P = @MKDIR_P@
+MKINSTALLDIRS = @MKINSTALLDIRS@
+MSGFMT = @MSGFMT@
+MSGMERGE = @MSGMERGE@
+OBJEXT = @OBJEXT@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+PATH_SEPARATOR = @PATH_SEPARATOR@
+PKGDATADIR = @PKGDATADIR@
+PKG_CONFIG = @PKG_CONFIG@
+POSUB = @POSUB@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+STRIP = @STRIP@
+USE_NLS = @USE_NLS@
+VERSION = @VERSION@
+XGETTEXT = @XGETTEXT@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_CC = @ac_ct_CC@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+datadir = @datadir@
+datarootdir = @datarootdir@
+docdir = @docdir@
+dvidir = @dvidir@
+exec_prefix = @exec_prefix@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = $(datadir)/locale
+localstatedir = @localstatedir@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target = @target@
+target_alias = @target_alias@
+target_cpu = @target_cpu@
+target_os = @target_os@
+target_vendor = @target_vendor@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+INCLUDES = -DLOCALEDIR=\"$(localedir)\" -DSYSCONFDIR=\"$(sysconfdir)\"
+ACLOCAL_AMFLAGS = -I m4
+nano_SOURCES = browser.c \
+		chars.c \
+		color.c \
+		cut.c \
+		files.c \
+		global.c \
+		help.c \
+		move.c \
+		nano.c \
+		nano.h \
+		prompt.c \
+		proto.h \
+		rcfile.c \
+		search.c \
+		text.c \
+		utils.c \
+		winio.c 
+
+nano_LDADD = @GLIB_LIBS@ @LIBINTL@
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .c .o .obj
+$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
+	@for dep in $?; do \
+	  case '$(am__configure_deps)' in \
+	    *$$dep*) \
+	      ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+	        && { if test -f $@; then exit 0; else break; fi; }; \
+	      exit 1;; \
+	  esac; \
+	done; \
+	echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/Makefile'; \
+	$(am__cd) $(top_srcdir) && \
+	  $(AUTOMAKE) --gnu src/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+	@case '$?' in \
+	  *config.status*) \
+	    cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+	  *) \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+	esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure:  $(am__configure_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4):  $(am__aclocal_m4_deps)
+	cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+install-binPROGRAMS: $(bin_PROGRAMS)
+	@$(NORMAL_INSTALL)
+	test -z "$(bindir)" || $(MKDIR_P) "$(DESTDIR)$(bindir)"
+	@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+	for p in $$list; do echo "$$p $$p"; done | \
+	sed 's/$(EXEEXT)$$//' | \
+	while read p p1; do if test -f $$p; \
+	  then echo "$$p"; echo "$$p"; else :; fi; \
+	done | \
+	sed -e 'p;s,.*/,,;n;h' -e 's|.*|.|' \
+	    -e 'p;x;s,.*/,,;s/$(EXEEXT)$$//;$(transform);s/$$/$(EXEEXT)/' | \
+	sed 'N;N;N;s,\n, ,g' | \
+	$(AWK) 'BEGIN { files["."] = ""; dirs["."] = 1 } \
+	  { d=$$3; if (dirs[d] != 1) { print "d", d; dirs[d] = 1 } \
+	    if ($$2 == $$4) files[d] = files[d] " " $$1; \
+	    else { print "f", $$3 "/" $$4, $$1; } } \
+	  END { for (d in files) print "f", d, files[d] }' | \
+	while read type dir files; do \
+	    if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
+	    test -z "$$files" || { \
+	      echo " $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(bindir)$$dir'"; \
+	      $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(bindir)$$dir" || exit $$?; \
+	    } \
+	; done
+
+uninstall-binPROGRAMS:
+	@$(NORMAL_UNINSTALL)
+	@list='$(bin_PROGRAMS)'; test -n "$(bindir)" || list=; \
+	files=`for p in $$list; do echo "$$p"; done | \
+	  sed -e 'h;s,^.*/,,;s/$(EXEEXT)$$//;$(transform)' \
+	      -e 's/$$/$(EXEEXT)/' `; \
+	test -n "$$list" || exit 0; \
+	echo " ( cd '$(DESTDIR)$(bindir)' && rm -f" $$files ")"; \
+	cd "$(DESTDIR)$(bindir)" && rm -f $$files
+
+clean-binPROGRAMS:
+	-test -z "$(bin_PROGRAMS)" || rm -f $(bin_PROGRAMS)
+nano$(EXEEXT): $(nano_OBJECTS) $(nano_DEPENDENCIES) 
+	@rm -f nano$(EXEEXT)
+	$(LINK) $(nano_OBJECTS) $(nano_LDADD) $(LIBS)
+
+mostlyclean-compile:
+	-rm -f *.$(OBJEXT)
+
+distclean-compile:
+	-rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/browser.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/chars.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/color.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cut.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/files.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/global.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/help.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/move.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/nano.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/prompt.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rcfile.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/search.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/text.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/utils.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/winio.Po@am__quote@
+
+.c.o:
+@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(COMPILE) -c $<
+
+.c.obj:
+@am__fastdepCC_TRUE@	$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
+@am__fastdepCC_TRUE@	$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@	$(COMPILE) -c `$(CYGPATH_W) '$<'`
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+	list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	mkid -fID $$unique
+tags: TAGS
+
+TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	set x; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	shift; \
+	if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+	  test -n "$$unique" || unique=$$empty_fix; \
+	  if test $$# -gt 0; then \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      "$$@" $$unique; \
+	  else \
+	    $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+	      $$unique; \
+	  fi; \
+	fi
+ctags: CTAGS
+CTAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+		$(TAGS_FILES) $(LISP)
+	list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+	unique=`for i in $$list; do \
+	    if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+	  done | \
+	  $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+	      END { if (nonempty) { for (i in files) print i; }; }'`; \
+	test -z "$(CTAGS_ARGS)$$unique" \
+	  || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+	     $$unique
+
+GTAGS:
+	here=`$(am__cd) $(top_builddir) && pwd` \
+	  && $(am__cd) $(top_srcdir) \
+	  && gtags -i $(GTAGS_ARGS) "$$here"
+
+distclean-tags:
+	-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+	@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+	list='$(DISTFILES)'; \
+	  dist_files=`for file in $$list; do echo $$file; done | \
+	  sed -e "s|^$$srcdirstrip/||;t" \
+	      -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+	case $$dist_files in \
+	  */*) $(MKDIR_P) `echo "$$dist_files" | \
+			   sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+			   sort -u` ;; \
+	esac; \
+	for file in $$dist_files; do \
+	  if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+	  if test -d $$d/$$file; then \
+	    dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+	    if test -d "$(distdir)/$$file"; then \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+	      cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+	      find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+	    fi; \
+	    cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+	  else \
+	    test -f "$(distdir)/$$file" \
+	    || cp -p $$d/$$file "$(distdir)/$$file" \
+	    || exit 1; \
+	  fi; \
+	done
+check-am: all-am
+check: check-am
+all-am: Makefile $(PROGRAMS)
+installdirs:
+	for dir in "$(DESTDIR)$(bindir)"; do \
+	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+	done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+	  install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+	  `test -z '$(STRIP)' || \
+	    echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+	@echo "This command is intended for maintainers to use"
+	@echo "it deletes files that may require special tools to rebuild."
+clean: clean-am
+
+clean-am: clean-binPROGRAMS clean-generic mostlyclean-am
+
+distclean: distclean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+	distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am:
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-binPROGRAMS
+	@$(NORMAL_INSTALL)
+	$(MAKE) $(AM_MAKEFLAGS) install-exec-hook
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+	-rm -rf ./$(DEPDIR)
+	-rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-binPROGRAMS
+	@$(NORMAL_INSTALL)
+	$(MAKE) $(AM_MAKEFLAGS) uninstall-hook
+.MAKE: install-am install-exec-am install-strip uninstall-am
+
+.PHONY: CTAGS GTAGS all all-am check check-am clean clean-binPROGRAMS \
+	clean-generic ctags distclean distclean-compile \
+	distclean-generic distclean-tags distdir dvi dvi-am html \
+	html-am info info-am install install-am install-binPROGRAMS \
+	install-data install-data-am install-dvi install-dvi-am \
+	install-exec install-exec-am install-exec-hook install-html \
+	install-html-am install-info install-info-am install-man \
+	install-pdf install-pdf-am install-ps install-ps-am \
+	install-strip installcheck installcheck-am installdirs \
+	maintainer-clean maintainer-clean-generic mostlyclean \
+	mostlyclean-compile mostlyclean-generic pdf pdf-am ps ps-am \
+	tags uninstall uninstall-am uninstall-binPROGRAMS \
+	uninstall-hook
+
+
+install-exec-hook:
+	cd $(DESTDIR)$(bindir) && rm -f rnano && $(LN_S) nano rnano
+uninstall-hook:
+	cd $(DESTDIR)$(bindir) && rm -f rnano
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/src/browser.c b/src/browser.c
new file mode 100644
index 0000000..3d32149
--- /dev/null
+++ b/src/browser.c
@@ -0,0 +1,1078 @@
+/* $Id: browser.c 4527 2011-02-07 14:45:56Z astyanax $ */
+/**************************************************************************
+ *   browser.c                                                            *
+ *                                                                        *
+ *   Copyright (C) 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 <string.h>
+#include <unistd.h>
+#include <errno.h>
+
+#ifndef DISABLE_BROWSER
+
+static char **filelist = NULL;
+	/* The list of files to display in the file browser. */
+static size_t filelist_len = 0;
+	/* The number of files in the list. */
+static int width = 0;
+	/* The number of files that we can display per line. */
+static int longest = 0;
+	/* The number of columns in the longest filename in the list. */
+static size_t selected = 0;
+	/* The currently selected filename in the list.  This variable
+	 * is zero-based. */
+static bool search_last_file = FALSE;
+	/* Have we gone past the last file while searching? */
+
+/* Our main file browser function.  path is the tilde-expanded path we
+ * start browsing from. */
+char *do_browser(char *path, DIR *dir)
+{
+    char *retval = NULL;
+    int kbinput;
+    bool meta_key, func_key, old_const_update = ISSET(CONST_UPDATE);
+    bool abort = FALSE;
+	/* Whether we should abort the file browser. */
+    char *prev_dir = NULL;
+	/* The directory we were in, if any, before backing up via
+	 * browsing to "..". */
+    char *ans = NULL;
+	/* The last answer the user typed at the statusbar prompt. */
+    size_t old_selected;
+	/* The selected file we had before the current selected file. */
+    const sc *s;
+    const subnfunc *f;
+
+    curs_set(0);
+    blank_statusbar();
+#if !defined(DISABLE_HELP) || !defined(DISABLE_MOUSE)
+    currmenu = MBROWSER;
+#endif
+    bottombars(MBROWSER);
+    wnoutrefresh(bottomwin);
+
+    UNSET(CONST_UPDATE);
+
+    ans = mallocstrcpy(NULL, "");
+
+  change_browser_directory:
+	/* We go here after we select a new directory. */
+
+    /* Start with no key pressed. */
+    kbinput = ERR;
+
+    path = mallocstrassn(path, get_full_path(path));
+
+    assert(path != NULL && path[strlen(path) - 1] == '/');
+
+    /* Get the file list, and set longest and width in the process. */
+    browser_init(path, dir);
+
+    assert(filelist != NULL);
+
+    /* Sort the file list. */
+    qsort(filelist, filelist_len, sizeof(char *), diralphasort);
+
+    /* If prev_dir isn't NULL, select the directory saved in it, and
+     * then blow it away. */
+    if (prev_dir != NULL) {
+	browser_select_filename(prev_dir);
+
+	free(prev_dir);
+	prev_dir = NULL;
+    /* Otherwise, select the first file or directory in the list. */
+    } else
+	selected = 0;
+
+    old_selected = (size_t)-1;
+
+    titlebar(path);
+
+    while (!abort) {
+	struct stat st;
+	int i;
+	size_t fileline = selected / width;
+		/* The line number the selected file is on. */
+	char *new_path;
+		/* The path we switch to at the "Go to Directory"
+		 * prompt. */
+
+	/* Display the file list if we don't have a key, or if the
+	 * selected file has changed, and set width in the process. */
+	if (kbinput == ERR || old_selected != selected)
+	    browser_refresh();
+
+	old_selected = selected;
+
+	kbinput = get_kbinput(edit, &meta_key, &func_key);
+
+#ifndef DISABLE_MOUSE
+        if (kbinput == KEY_MOUSE) {
+
+		    int mouse_x, mouse_y;
+
+		    /* We can click on the edit window to select a
+		     * filename. */
+		    if (get_mouseinput(&mouse_x, &mouse_y, TRUE) == 0 &&
+			wmouse_trafo(edit, &mouse_y, &mouse_x, FALSE)) {
+			/* longest is the width of each column.  There
+			 * are two spaces between each column. */
+			selected = (fileline / editwinrows) *
+				(editwinrows * width) + (mouse_y *
+				width) + (mouse_x / (longest + 2));
+
+			/* If they clicked beyond the end of a row,
+			 * select the filename at the end of that
+			 * row. */
+			if (mouse_x > width * (longest + 2))
+			    selected--;
+
+			/* If we're off the screen, select the last
+			 * filename. */
+			if (selected > filelist_len - 1)
+			    selected = filelist_len - 1;
+
+			/* If we selected the same filename as last
+			 * time, put back the Enter key so that it's
+			 * read in. */
+			if (old_selected == selected)
+			    unget_kbinput(sc_seq_or(do_enter_void, 0), FALSE, FALSE);
+		    }
+	}
+#endif /* !DISABLE_MOUSE */
+
+	parse_browser_input(&kbinput, &meta_key, &func_key);
+        s = get_shortcut(MBROWSER, &kbinput, &meta_key, &func_key);
+        if (!s)
+            continue;
+        f = sctofunc((sc *) s);
+        if (!f)
+            break;
+
+	if (f->scfunc == total_refresh) {
+		total_redraw();
+	} else if (f->scfunc == do_help_void) {
+#ifndef DISABLE_HELP
+	    do_browser_help();
+	    curs_set(0);
+#else
+		nano_disabled_msg();
+#endif
+	    /* Search for a filename. */
+	} else if (f->scfunc == do_search) {
+		curs_set(1);
+		do_filesearch();
+		curs_set(0);
+	    /* Search for another filename. */
+	} else if (f->scfunc == do_research) {
+		do_fileresearch();
+	} else if (f->scfunc == do_page_up) {
+		if (selected >= (editwinrows + fileline % editwinrows) *
+			width)
+		    selected -= (editwinrows + fileline % editwinrows) *
+			width;
+		else
+		    selected = 0;
+	} else if (f->scfunc == do_page_down) {
+		selected += (editwinrows - fileline % editwinrows) *
+			width;
+		if (selected > filelist_len - 1)
+		    selected = filelist_len - 1;
+	} else if (f->scfunc == do_first_file) {
+		if (meta_key)
+		    selected = 0;
+	} else if (f->scfunc == do_last_file) {
+		if (meta_key)
+		    selected = filelist_len - 1;
+	    /* Go to a specific directory. */
+	} else if (f->scfunc == goto_dir_void) {
+		curs_set(1);
+
+		i = do_prompt(TRUE,
+#ifndef DISABLE_TABCOMP
+			FALSE,
+#endif
+			MGOTODIR, ans,
+			&meta_key, &func_key,
+#ifndef NANO_TINY
+			NULL,
+#endif
+			browser_refresh, N_("Go To Directory"));
+
+		curs_set(0);
+#if !defined(DISABLE_HELP) || !defined(DISABLE_MOUSE)
+		currmenu = MBROWSER;
+#endif
+		bottombars(MBROWSER);
+
+		/* If the directory begins with a newline (i.e. an
+		 * encoded null), treat it as though it's blank. */
+		if (i < 0 || *answer == '\n') {
+		    /* We canceled.  Indicate that on the statusbar, and
+		     * blank out ans, since we're done with it. */
+		    statusbar(_("Cancelled"));
+		    ans = mallocstrcpy(ans, "");
+		    continue;
+		} else if (i != 0) {
+		    /* Put back the "Go to Directory" key and save
+		     * answer in ans, so that the file list is displayed
+		     * again, the prompt is displayed again, and what we
+		     * typed before at the prompt is displayed again. */
+		    unget_kbinput(sc_seq_or(do_gotolinecolumn_void, 0), FALSE, FALSE);
+		    ans = mallocstrcpy(ans, answer);
+		    continue;
+		}
+
+		/* We have a directory.  Blank out ans, since we're done
+		 * with it. */
+		ans = mallocstrcpy(ans, "");
+
+		/* Convert newlines to nulls, just before we go to the
+		 * directory. */
+		sunder(answer);
+		align(&answer);
+
+		new_path = real_dir_from_tilde(answer);
+
+		if (new_path[0] != '/') {
+		    new_path = charealloc(new_path, strlen(path) +
+			strlen(answer) + 1);
+		    sprintf(new_path, "%s%s", path, answer);
+		}
+
+#ifndef DISABLE_OPERATINGDIR
+		if (check_operating_dir(new_path, FALSE)) {
+		    statusbar(
+			_("Can't go outside of %s in restricted mode"),
+			operating_dir);
+		    free(new_path);
+		    continue;
+		}
+#endif
+
+		dir = opendir(new_path);
+		if (dir == NULL) {
+		    /* We can't open this directory for some reason.
+		     * Complain. */
+		    statusbar(_("Error reading %s: %s"), answer,
+			strerror(errno));
+		    beep();
+		    free(new_path);
+		    continue;
+		}
+
+		/* Start over again with the new path value. */
+		free(path);
+		path = new_path;
+		goto change_browser_directory;
+	} else if (f->scfunc == do_up_void) {
+		if (selected >= width)
+		    selected -= width;
+	} else if (f->scfunc == do_left) {
+		if (selected > 0)
+		    selected--;
+	} else if (f->scfunc == do_down_void) {
+		if (selected + width <= filelist_len - 1)
+		    selected += width;
+	} else if (f->scfunc == do_right) {
+		if (selected < filelist_len - 1)
+		    selected++;
+	} else if (f->scfunc == do_enter_void) {
+		/* We can't move up from "/". */
+		if (strcmp(filelist[selected], "/..") == 0) {
+		    statusbar(_("Can't move up a directory"));
+		    beep();
+		    continue;
+		}
+
+#ifndef DISABLE_OPERATINGDIR
+		/* Note: The selected file can be outside the operating
+		 * directory if it's ".." or if it's a symlink to a
+		 * directory outside the operating directory. */
+		if (check_operating_dir(filelist[selected], FALSE)) {
+		    statusbar(
+			_("Can't go outside of %s in restricted mode"),
+			operating_dir);
+		    beep();
+		    continue;
+		}
+#endif
+
+		if (stat(filelist[selected], &st) == -1) {
+		    /* We can't open this file for some reason.
+		     * Complain. */
+		    statusbar(_("Error reading %s: %s"),
+			filelist[selected], strerror(errno));
+		    beep();
+		    continue;
+		}
+
+		/* If we've successfully opened a file, we're done, so
+		 * get out. */
+		if (!S_ISDIR(st.st_mode)) {
+		    retval = mallocstrcpy(NULL, filelist[selected]);
+		    abort = TRUE;
+		    continue;
+		/* If we've successfully opened a directory, and it's
+		 * "..", save the current directory in prev_dir, so that
+		 * we can select it later. */
+		} else if (strcmp(tail(filelist[selected]), "..") == 0)
+		    prev_dir = mallocstrcpy(NULL,
+			striponedir(filelist[selected]));
+
+		dir = opendir(filelist[selected]);
+		if (dir == NULL) {
+		    /* We can't open this directory for some reason.
+		     * Complain. */
+		    statusbar(_("Error reading %s: %s"),
+			filelist[selected], strerror(errno));
+		    beep();
+		    continue;
+		}
+
+		path = mallocstrcpy(path, filelist[selected]);
+
+		/* Start over again with the new path value. */
+		goto change_browser_directory;
+	    /* Abort the file browser. */
+	} else if (f->scfunc == do_exit) {
+		abort = TRUE;
+	}
+    }
+    titlebar(NULL);
+    edit_refresh();
+    curs_set(1);
+    if (old_const_update)
+	SET(CONST_UPDATE);
+
+    free(path);
+    free(ans);
+
+    free_chararray(filelist, filelist_len);
+    filelist = NULL;
+    filelist_len = 0;
+
+    return retval;
+}
+
+/* The file browser front end.  We check to see if inpath has a
+ * directory in it.  If it does, we start do_browser() from there.
+ * Otherwise, we start do_browser() from the current directory. */
+char *do_browse_from(const char *inpath)
+{
+    struct stat st;
+    char *path;
+	/* This holds the tilde-expanded version of inpath. */
+    DIR *dir = NULL;
+
+    assert(inpath != NULL);
+
+    path = real_dir_from_tilde(inpath);
+
+    /* Perhaps path is a directory.  If so, we'll pass it to
+     * do_browser().  Or perhaps path is a directory / a file.  If so,
+     * we'll try stripping off the last path element and passing it to
+     * do_browser().  Or perhaps path doesn't have a directory portion
+     * at all.  If so, we'll just pass the current directory to
+     * do_browser(). */
+    if (stat(path, &st) == -1 || !S_ISDIR(st.st_mode)) {
+	path = mallocstrassn(path, striponedir(path));
+
+	if (stat(path, &st) == -1 || !S_ISDIR(st.st_mode)) {
+	    free(path);
+
+	    path = charalloc(PATH_MAX + 1);
+	    path = getcwd(path, PATH_MAX + 1);
+
+	    if (path != NULL)
+		align(&path);
+	}
+    }
+
+#ifndef DISABLE_OPERATINGDIR
+    /* If the resulting path isn't in the operating directory, use
+     * the operating directory instead. */
+    if (check_operating_dir(path, FALSE))
+	path = mallocstrcpy(path, operating_dir);
+#endif
+
+    if (path != NULL)
+	dir = opendir(path);
+
+    /* If we can't open the path, get out. */
+    if (dir == NULL) {
+	if (path != NULL)
+	    free(path);
+	beep();
+	return NULL;
+    }
+
+    return do_browser(path, dir);
+}
+
+/* Set filelist to the list of files contained in the directory path,
+ * set filelist_len to the number of files in that list, set longest to
+ * the width in columns of the longest filename in that list (between 15
+ * and COLS), and set width to the number of files that we can display
+ * per line.  longest needs to be at least 15 columns in order to
+ * display ".. (parent dir)", as Pico does.  Assume path exists and is a
+ * directory. */
+void browser_init(const char *path, DIR *dir)
+{
+    const struct dirent *nextdir;
+    size_t i = 0, path_len = strlen(path);
+    int col = 0;
+	/* The maximum number of columns that the filenames will take
+	 * up. */
+    int line = 0;
+	/* The maximum number of lines that the filenames will take
+	 * up. */
+    int filesperline = 0;
+	/* The number of files that we can display per line. */
+
+    assert(path != NULL && path[strlen(path) - 1] == '/' && dir != NULL);
+
+    /* Set longest to zero, just before we initialize it. */
+    longest = 0;
+
+    while ((nextdir = readdir(dir)) != NULL) {
+	size_t d_len;
+
+	/* Don't show the "." entry. */
+	if (strcmp(nextdir->d_name, ".") == 0)
+	   continue;
+
+	d_len = strlenpt(nextdir->d_name);
+	if (d_len > longest)
+	    longest = (d_len > COLS) ? COLS : d_len;
+
+	i++;
+    }
+
+    rewinddir(dir);
+
+    /* Put 10 columns' worth of blank space between columns of filenames
+     * in the list whenever possible, as Pico does. */
+    longest += 10;
+
+    if (filelist != NULL)
+	free_chararray(filelist, filelist_len);
+
+    filelist_len = i;
+
+    filelist = (char **)nmalloc(filelist_len * sizeof(char *));
+
+    i = 0;
+
+    while ((nextdir = readdir(dir)) != NULL && i < filelist_len) {
+	/* Don't show the "." entry. */
+	if (strcmp(nextdir->d_name, ".") == 0)
+	   continue;
+
+	filelist[i] = charalloc(path_len + strlen(nextdir->d_name) + 1);
+	sprintf(filelist[i], "%s%s", path, nextdir->d_name);
+
+	i++;
+    }
+
+    /* Maybe the number of files in the directory changed between the
+     * first time we scanned and the second.  i is the actual length of
+     * filelist, so record it. */
+    filelist_len = i;
+
+    closedir(dir);
+
+    /* Make sure longest is between 15 and COLS. */
+    if (longest < 15)
+	longest = 15;
+    if (longest > COLS)
+	longest = COLS;
+
+    /* Set width to zero, just before we initialize it. */
+    width = 0;
+
+    for (i = 0; i < filelist_len && line < editwinrows; i++) {
+	/* Calculate the number of columns one filename will take up. */
+	col += longest;
+	filesperline++;
+
+	/* Add some space between the columns. */
+	col += 2;
+
+	/* If the next entry isn't going to fit on the current line,
+	 * move to the next line. */
+	if (col > COLS - longest) {
+	    line++;
+	    col = 0;
+
+	    /* If width isn't initialized yet, and we've taken up more
+	     * than one line, it means that width is equal to
+	     * filesperline. */
+	    if (width == 0)
+		width = filesperline;
+	}
+    }
+
+    /* If width isn't initialized yet, and we've taken up only one line,
+     * it means that width is equal to longest. */
+    if (width == 0)
+	width = longest;
+}
+
+/* Determine the shortcut key corresponding to the values of kbinput
+ * (the key itself), meta_key (whether the key is a meta sequence), and
+ * func_key (whether the key is a function key), if any.  In the
+ * process, convert certain non-shortcut keys into their corresponding
+ * shortcut keys. */
+void parse_browser_input(int *kbinput, bool *meta_key, bool *func_key)
+{
+    get_shortcut(MBROWSER, kbinput, meta_key, func_key);
+
+    /* Pico compatibility. */
+    if (!*meta_key) {
+	switch (*kbinput) {
+	    case ' ':
+		*kbinput = sc_seq_or(do_page_down, 0);
+		break;
+	    case '-':
+		*kbinput = sc_seq_or(do_page_up, 0);
+		break;
+	    case '?':
+#ifndef DISABLE_HELP
+		*kbinput = sc_seq_or(do_help_void, 0);
+#endif
+		break;
+	    /* Cancel equivalent to Exit here. */
+	    case 'E':
+	    case 'e':
+		*kbinput = sc_seq_or(do_exit, 0);
+		break;
+	    case 'G':
+	    case 'g':
+		*kbinput = sc_seq_or(goto_dir_void, 0);
+		break;
+	    case 'S':
+	    case 's':
+		*kbinput = sc_seq_or(do_enter_void, 0);
+		break;
+	    case 'W':
+	    case 'w':
+		*kbinput = sc_seq_or(do_search, 0);
+		break;
+	}
+    }
+}
+
+/* Set width to the number of files that we can display per line, if
+ * necessary, and display the list of files. */
+void browser_refresh(void)
+{
+    static int uimax_digits = -1;
+    size_t i;
+    int col = 0;
+	/* The maximum number of columns that the filenames will take
+	 * up. */
+    int line = 0;
+	/* The maximum number of lines that the filenames will take
+	 * up. */
+    char *foo;
+	/* The file information that we'll display. */
+
+    if (uimax_digits == -1)
+	uimax_digits = digits(UINT_MAX);
+
+    blank_edit();
+
+    wmove(edit, 0, 0);
+
+    i = width * editwinrows * ((selected / width) / editwinrows);
+
+    for (; i < filelist_len && line < editwinrows; i++) {
+	struct stat st;
+	const char *filetail = tail(filelist[i]);
+		/* The filename we display, minus the path. */
+	size_t filetaillen = strlenpt(filetail);
+		/* The length of the filename in columns. */
+	size_t foolen;
+		/* The length of the file information in columns. */
+	int foomaxlen = 7;
+		/* The maximum length of the file information in
+		 * columns: seven for "--", "(dir)", or the file size,
+		 * and 12 for "(parent dir)". */
+	bool dots = (COLS >= 15 && filetaillen >= longest -
+		foomaxlen - 1);
+		/* Do we put an ellipsis before the filename?  Don't set
+		 * this to TRUE if we have fewer than 15 columns (i.e.
+		 * one column for padding, plus seven columns for a
+		 * filename other than ".."). */
+	char *disp = display_string(filetail, dots ? filetaillen -
+		longest + foomaxlen + 4 : 0, longest, FALSE);
+		/* If we put an ellipsis before the filename, reserve
+		 * one column for padding, plus seven columns for "--",
+		 * "(dir)", or the file size, plus three columns for the
+		 * ellipsis. */
+
+	/* Start highlighting the currently selected file or
+	 * directory. */
+	if (i == selected)
+	    wattron(edit, reverse_attr);
+
+	blank_line(edit, line, col, longest);
+
+	/* If dots is TRUE, we will display something like
+	 * "...ename". */
+	if (dots)
+	    mvwaddstr(edit, line, col, "...");
+	mvwaddstr(edit, line, dots ? col + 3 : col, disp);
+
+	free(disp);
+
+	col += longest;
+
+	/* Show information about the file.  We don't want to report
+	 * file sizes for links, so we use lstat(). */
+	if (lstat(filelist[i], &st) == -1 || S_ISLNK(st.st_mode)) {
+	    /* If the file doesn't exist (i.e. it's been deleted while
+	     * the file browser is open), or it's a symlink that doesn't
+	     * point to a directory, display "--". */
+	    if (stat(filelist[i], &st) == -1 || !S_ISDIR(st.st_mode))
+		foo = mallocstrcpy(NULL, "--");
+	    /* If the file is a symlink that points to a directory,
+	     * display it as a directory. */
+	    else
+		/* TRANSLATORS: Try to keep this at most 7
+		 * characters. */
+		foo = mallocstrcpy(NULL, _("(dir)"));
+	} else if (S_ISDIR(st.st_mode)) {
+	    /* If the file is a directory, display it as such. */
+	    if (strcmp(filetail, "..") == 0) {
+		/* TRANSLATORS: Try to keep this at most 12
+		 * characters. */
+		foo = mallocstrcpy(NULL, _("(parent dir)"));
+		foomaxlen = 12;
+	    } else
+		foo = mallocstrcpy(NULL, _("(dir)"));
+	} else {
+	    unsigned long result = st.st_size;
+	    char modifier;
+
+	    foo = charalloc(uimax_digits + 4);
+
+	    /* Bytes. */
+	    if (st.st_size < (1 << 10))
+		modifier = ' ';
+	    /* Kilobytes. */
+	    else if (st.st_size < (1 << 20)) {
+		result >>= 10;
+		modifier = 'K';
+	    /* Megabytes. */
+	    } else if (st.st_size < (1 << 30)) {
+		result >>= 20;
+		modifier = 'M';
+	    /* Gigabytes. */
+	    } else {
+		result >>= 30;
+		modifier = 'G';
+	    }
+
+	    sprintf(foo, "%4lu %cB", result, modifier);
+	}
+
+	/* Make sure foo takes up no more than foomaxlen columns. */
+	foolen = strlenpt(foo);
+	if (foolen > foomaxlen) {
+	    null_at(&foo, actual_x(foo, foomaxlen));
+	    foolen = foomaxlen;
+	}
+
+	mvwaddstr(edit, line, col - foolen, foo);
+
+	/* Finish highlighting the currently selected file or
+	 * directory. */
+	if (i == selected)
+	    wattroff(edit, reverse_attr);
+
+	free(foo);
+
+	/* Add some space between the columns. */
+	col += 2;
+
+	/* If the next entry isn't going to fit on the current line,
+	 * move to the next line. */
+	if (col > COLS - longest) {
+	    line++;
+	    col = 0;
+	}
+
+	wmove(edit, line, col);
+    }
+
+    wnoutrefresh(edit);
+}
+
+/* Look for needle.  If we find it, set selected to its location.  Note
+ * that needle must be an exact match for a file in the list.  The
+ * return value specifies whether we found anything. */
+bool browser_select_filename(const char *needle)
+{
+    size_t currselected;
+    bool found = FALSE;
+
+    for (currselected = 0; currselected < filelist_len;
+	currselected++) {
+	if (strcmp(filelist[currselected], needle) == 0) {
+	    found = TRUE;
+	    break;
+	}
+    }
+
+    if (found)
+	selected = currselected;
+
+    return found;
+}
+
+/* Set up the system variables for a filename search.  Return -1 if the
+ * search should be canceled (due to Cancel, a blank search string, or a
+ * failed regcomp()), return 0 on success, and return 1 on rerun calling
+ * program. */
+int filesearch_init(void)
+{
+    int i = 0;
+    char *buf;
+    bool meta_key, func_key;
+    const sc *s;
+    static char *backupstring = NULL;
+	/* The search string we'll be using. */
+
+    /* If backupstring doesn't exist, initialize it to "". */
+    if (backupstring == NULL)
+	backupstring = mallocstrcpy(NULL, "");
+
+    /* We display the search prompt below.  If the user types a partial
+     * search string and then Replace or a toggle, we will return to
+     * do_search() or do_replace() and be called again.  In that case,
+     * we should put the same search string back up. */
+
+    search_init_globals();
+
+    if (last_search[0] != '\0') {
+	char *disp = display_string(last_search, 0, COLS / 3, FALSE);
+
+	buf = charalloc(strlen(disp) + 7);
+	/* We use (COLS / 3) here because we need to see more on the
+	 * line. */
+	sprintf(buf, " [%s%s]", disp,
+		(strlenpt(last_search) > COLS / 3) ? "..." : "");
+	free(disp);
+    } else
+	buf = mallocstrcpy(NULL, "");
+
+    /* This is now one simple call.  It just does a lot. */
+    i = do_prompt(FALSE,
+#ifndef DISABLE_TABCOMP
+	TRUE,
+#endif
+	MWHEREISFILE, backupstring,
+	&meta_key, &func_key, 
+#ifndef NANO_TINY
+	&search_history,
+#endif
+	browser_refresh, "%s%s%s%s%s%s", _("Search"),
+#ifndef NANO_TINY
+	/* This string is just a modifier for the search prompt; no
+	 * grammar is implied. */
+	ISSET(CASE_SENSITIVE) ? _(" [Case Sensitive]") :
+#endif
+	"",
+#ifdef HAVE_REGEX_H
+	/* This string is just a modifier for the search prompt; no
+	 * grammar is implied. */
+	ISSET(USE_REGEXP) ? _(" [Regexp]") :
+#endif
+	"",
+#ifndef NANO_TINY
+	/* This string is just a modifier for the search prompt; no
+	 * grammar is implied. */
+	ISSET(BACKWARDS_SEARCH) ? _(" [Backwards]") :
+#endif
+	"", "", buf);
+
+    /* Release buf now that we don't need it anymore. */
+    free(buf);
+
+    free(backupstring);
+    backupstring = NULL;
+
+    /* Cancel any search, or just return with no previous search. */
+    if (i == -1 || (i < 0 && *last_search == '\0') || (i == 0 &&
+	*answer == '\0')) {
+	statusbar(_("Cancelled"));
+	return -1;
+    } else {
+        s = get_shortcut(MBROWSER, &i, &meta_key, &func_key);
+	if (i == -2 || i == 0) {
+#ifdef HAVE_REGEX_H
+		/* Use last_search if answer is an empty string, or
+		 * answer if it isn't. */
+		if (ISSET(USE_REGEXP) && !regexp_init((i == -2) ?
+			last_search : answer))
+		    return -1;
+#endif
+	} else
+#ifndef NANO_TINY
+	if (s && s->scfunc == case_sens_void) {
+		TOGGLE(CASE_SENSITIVE);
+		backupstring = mallocstrcpy(backupstring, answer);
+		return 1;
+	} else if (s && s->scfunc ==  backwards_void) {
+		TOGGLE(BACKWARDS_SEARCH);
+		backupstring = mallocstrcpy(backupstring, answer);
+		return 1;
+	} else
+#endif
+#ifdef HAVE_REGEX_H
+	if (s && s->scfunc == regexp_void) {
+		TOGGLE(USE_REGEXP);
+		backupstring = mallocstrcpy(backupstring, answer);
+		return 1;
+	} else
+#endif
+	    return -1;
+    }
+
+    return 0;
+}
+
+/* Look for needle.  If no_sameline is TRUE, skip over selected when
+ * looking for needle.  begin is the location of the filename where we
+ * first started searching.  The return value specifies whether we found
+ * anything. */
+bool findnextfile(bool no_sameline, size_t begin, const char *needle)
+{
+    size_t currselected = selected;
+	/* The location in the current file list of the match we
+	 * find. */
+    const char *filetail = tail(filelist[currselected]);
+	/* The filename we display, minus the path. */
+    const char *rev_start = filetail, *found = NULL;
+
+#ifndef NANO_TINY
+    if (ISSET(BACKWARDS_SEARCH))
+	rev_start += strlen(rev_start);
+#endif
+
+    /* Look for needle in the current filename we're searching. */
+    while (TRUE) {
+	found = strstrwrapper(filetail, needle, rev_start);
+
+	/* We've found a potential match.  If we're not allowed to find
+	 * a match on the same filename we started on and this potential
+	 * match is on that line, continue searching. */
+	if (found != NULL && (!no_sameline || currselected != begin))
+	    break;
+
+	/* We've finished processing the filenames, so get out. */
+	if (search_last_file) {
+	    not_found_msg(needle);
+	    return FALSE;
+	}
+
+	/* Move to the previous or next filename in the list.  If we've
+	 * reached the start or end of the list, wrap around. */
+#ifndef NANO_TINY
+	if (ISSET(BACKWARDS_SEARCH)) {
+	    if (currselected > 0)
+		currselected--;
+	    else {
+		currselected = filelist_len - 1;
+		statusbar(_("Search Wrapped"));
+	    }
+	} else {
+#endif
+	    if (currselected < filelist_len - 1)
+		currselected++;
+	    else {
+		currselected = 0;
+		statusbar(_("Search Wrapped"));
+	    }
+#ifndef NANO_TINY
+	}
+#endif
+
+	/* We've reached the original starting file. */
+	if (currselected == begin)
+	    search_last_file = TRUE;
+
+	filetail = tail(filelist[currselected]);
+
+	rev_start = filetail;
+#ifndef NANO_TINY
+	if (ISSET(BACKWARDS_SEARCH))
+	    rev_start += strlen(rev_start);
+#endif
+    }
+
+    /* We've definitely found something. */
+    selected = currselected;
+
+    return TRUE;
+}
+
+/* Clear the flag indicating that a search reached the last file in the
+ * list.  We need to do this just before a new search. */
+void findnextfile_wrap_reset(void)
+{
+    search_last_file = FALSE;
+}
+
+/* Abort the current filename search.  Clean up by setting the current
+ * shortcut list to the browser shortcut list, displaying it, and
+ * decompiling the compiled regular expression we used in the last
+ * search, if any. */
+void filesearch_abort(void)
+{
+    currmenu = MBROWSER;
+    bottombars(MBROWSER);
+#ifdef HAVE_REGEX_H
+    regexp_cleanup();
+#endif
+}
+
+/* Search for a filename. */
+void do_filesearch(void)
+{
+    size_t begin = selected;
+    int i;
+    bool didfind;
+
+    i = filesearch_init();
+    if (i == -1)	/* Cancel, blank search string, or regcomp()
+			 * failed. */
+	filesearch_abort();
+#if !defined(NANO_TINY) || defined(HAVE_REGEX_H)
+    else if (i == 1)	/* Case Sensitive, Backwards, or Regexp search
+			 * toggle. */
+	do_filesearch();
+#endif
+
+    if (i != 0)
+	return;
+
+    /* If answer is now "", copy last_search into answer. */
+    if (*answer == '\0')
+	answer = mallocstrcpy(answer, last_search);
+    else
+	last_search = mallocstrcpy(last_search, answer);
+
+#ifndef NANO_TINY
+    /* If answer is not "", add this search string to the search history
+     * list. */
+    if (answer[0] != '\0')
+	update_history(&search_history, answer);
+#endif
+
+    findnextfile_wrap_reset();
+    didfind = findnextfile(FALSE, begin, answer);
+
+    /* Check to see if there's only one occurrence of the string and
+     * we're on it now. */
+    if (selected == begin && didfind) {
+	/* Do the search again, skipping over the current line.  We
+	 * should only end up back at the same position if the string
+	 * isn't found again, in which case it's the only occurrence. */
+	didfind = findnextfile(TRUE, begin, answer);
+	if (selected == begin && !didfind)
+	    statusbar(_("This is the only occurrence"));
+    }
+
+    filesearch_abort();
+}
+
+/* Search for the last filename without prompting. */
+void do_fileresearch(void)
+{
+    size_t begin = selected;
+    bool didfind;
+
+    search_init_globals();
+
+    if (last_search[0] != '\0') {
+#ifdef HAVE_REGEX_H
+	/* Since answer is "", use last_search! */
+	if (ISSET(USE_REGEXP) && !regexp_init(last_search))
+	    return;
+#endif
+
+	findnextfile_wrap_reset();
+	didfind = findnextfile(FALSE, begin, answer);
+
+	/* Check to see if there's only one occurrence of the string and
+	 * we're on it now. */
+	if (selected == begin && didfind) {
+	    /* Do the search again, skipping over the current line.  We
+	     * should only end up back at the same position if the
+	     * string isn't found again, in which case it's the only
+	     * occurrence. */
+	    didfind = findnextfile(TRUE, begin, answer);
+	    if (selected == begin && !didfind)
+		statusbar(_("This is the only occurrence"));
+	}
+    } else
+        statusbar(_("No current search pattern"));
+
+    filesearch_abort();
+}
+
+/* Select the first file in the list. */
+void do_first_file(void)
+{
+    selected = 0;
+}
+
+/* Select the last file in the list. */
+void do_last_file(void)
+{
+    selected = filelist_len - 1;
+}
+
+/* Strip one directory from the end of path, and return the stripped
+ * path.  The returned string is dynamically allocated, and should be
+ * freed. */
+char *striponedir(const char *path)
+{
+    char *retval, *tmp;
+
+    assert(path != NULL);
+
+    retval = mallocstrcpy(NULL, path);
+
+    tmp = strrchr(retval, '/');
+
+    if (tmp != NULL)
+ 	null_at(&retval, tmp - retval);
+
+    return retval;
+}
+
+#endif /* !DISABLE_BROWSER */
diff --git a/src/chars.c b/src/chars.c
new file mode 100644
index 0000000..e4309b7
--- /dev/null
+++ b/src/chars.c
@@ -0,0 +1,963 @@
+/* $Id: chars.c 4534 2011-02-24 02:47:25Z astyanax $ */
+/**************************************************************************
+ *   chars.c                                                              *
+ *                                                                        *
+ *   Copyright (C) 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 <string.h>
+#include <ctype.h>
+
+#ifdef ENABLE_UTF8
+#ifdef HAVE_WCHAR_H
+#include <wchar.h>
+#endif
+#ifdef HAVE_WCTYPE_H
+#include <wctype.h>
+#endif
+
+static bool use_utf8 = FALSE;
+	/* Whether we've enabled UTF-8 support. */
+static const wchar_t bad_wchar = 0xFFFD;
+	/* If we get an invalid multibyte sequence, we treat it as
+	 * Unicode FFFD (Replacement Character), unless we're searching
+	 * for a match to it. */
+static const char *const bad_mbchar = "\xEF\xBF\xBD";
+static const int bad_mbchar_len = 3;
+
+/* Enable UTF-8 support. */
+void utf8_init(void)
+{
+    use_utf8 = TRUE;
+}
+
+/* Is UTF-8 support enabled? */
+bool using_utf8(void)
+{
+    return use_utf8;
+}
+#endif
+
+#ifndef HAVE_ISBLANK
+/* This function is equivalent to isblank(). */
+bool nisblank(int c)
+{
+    return isspace(c) && (c == '\t' || !is_cntrl_char(c));
+}
+#endif
+
+#if !defined(HAVE_ISWBLANK) && defined(ENABLE_UTF8)
+/* This function is equivalent to iswblank(). */
+bool niswblank(wchar_t wc)
+{
+    return iswspace(wc) && (wc == '\t' || !is_cntrl_wchar(wc));
+}
+#endif
+
+/* Return TRUE if the value of c is in byte range, and FALSE
+ * otherwise. */
+bool is_byte(int c)
+{
+    return ((unsigned int)c == (unsigned char)c);
+}
+
+static void mbtowc_reset(void)
+{
+    IGNORE_CALL_RESULT(mbtowc(NULL, NULL, 0));
+}
+
+static void wctomb_reset(void)
+{
+    IGNORE_CALL_RESULT(wctomb(NULL, 0));
+}
+
+/* This function is equivalent to isalnum() for multibyte characters. */
+bool is_alnum_mbchar(const char *c)
+{
+    assert(c != NULL);
+
+#ifdef ENABLE_UTF8
+    if (use_utf8) {
+	wchar_t wc;
+
+	if (mbtowc(&wc, c, MB_CUR_MAX) < 0) {
+	    mbtowc_reset();
+	    wc = bad_wchar;
+	}
+
+	return iswalnum(wc);
+    } else
+#endif
+	return isalnum((unsigned char)*c);
+}
+
+/* This function is equivalent to isblank() for multibyte characters. */
+bool is_blank_mbchar(const char *c)
+{
+    assert(c != NULL);
+
+#ifdef ENABLE_UTF8
+    if (use_utf8) {
+	wchar_t wc;
+
+	if (mbtowc(&wc, c, MB_CUR_MAX) < 0) {
+	    mbtowc_reset();
+	    wc = bad_wchar;
+	}
+
+	return iswblank(wc);
+    } else
+#endif
+	return isblank((unsigned char)*c);
+}
+
+/* This function is equivalent to iscntrl(), except in that it only
+ * handles non-high-bit control characters. */
+bool is_ascii_cntrl_char(int c)
+{
+    return (0 <= c && c < 32);
+}
+
+/* This function is equivalent to iscntrl(), except in that it also
+ * handles high-bit control characters. */
+bool is_cntrl_char(int c)
+{
+    return (-128 <= c && c < -96) || (0 <= c && c < 32) ||
+	(127 <= c && c < 160);
+}
+
+#ifdef ENABLE_UTF8
+/* This function is equivalent to iscntrl() for wide characters, except
+ * in that it also handles wide control characters with their high bits
+ * set. */
+bool is_cntrl_wchar(wchar_t wc)
+{
+    return (0 <= wc && wc < 32) || (127 <= wc && wc < 160);
+}
+#endif
+
+/* This function is equivalent to iscntrl() for multibyte characters,
+ * except in that it also handles multibyte control characters with
+ * their high bits set. */
+bool is_cntrl_mbchar(const char *c)
+{
+    assert(c != NULL);
+
+#ifdef ENABLE_UTF8
+    if (use_utf8) {
+	wchar_t wc;
+
+	if (mbtowc(&wc, c, MB_CUR_MAX) < 0) {
+	    mbtowc_reset();
+	    wc = bad_wchar;
+	}
+
+	return is_cntrl_wchar(wc);
+    } else
+#endif
+	return is_cntrl_char((unsigned char)*c);
+}
+
+/* This function is equivalent to ispunct() for multibyte characters. */
+bool is_punct_mbchar(const char *c)
+{
+    assert(c != NULL);
+
+#ifdef ENABLE_UTF8
+    if (use_utf8) {
+	wchar_t wc;
+	int c_mb_len = mbtowc(&wc, c, MB_CUR_MAX);
+
+	if (c_mb_len < 0) {
+	    mbtowc_reset();
+	    wc = bad_wchar;
+	}
+
+	return iswpunct(wc);
+    } else
+#endif
+	return ispunct((unsigned char)*c);
+}
+
+/* Return TRUE for a multibyte character found in a word (currently only
+ * an alphanumeric or punctuation character, and only the latter if
+ * allow_punct is TRUE) and FALSE otherwise. */
+bool is_word_mbchar(const char *c, bool allow_punct)
+{
+    assert(c != NULL);
+
+    return is_alnum_mbchar(c) || (allow_punct ? is_punct_mbchar(c) :
+	FALSE);
+}
+
+/* c is a control character.  It displays as ^@, ^?, or ^[ch], where ch
+ * is (c + 64).  We return that character. */
+char control_rep(char c)
+{
+    assert(is_cntrl_char(c));
+
+    /* Treat newlines embedded in a line as encoded nulls. */
+    if (c == '\n')
+	return '@';
+    else if (c == NANO_CONTROL_8)
+	return '?';
+    else
+	return c + 64;
+}
+
+#ifdef ENABLE_UTF8
+/* c is a wide control character.  It displays as ^@, ^?, or ^[ch],
+ * where ch is (c + 64).  We return that wide character. */
+wchar_t control_wrep(wchar_t wc)
+{
+    assert(is_cntrl_wchar(wc));
+
+    /* Treat newlines embedded in a line as encoded nulls. */
+    if (wc == '\n')
+	return '@';
+    else if (wc == NANO_CONTROL_8)
+	return '?';
+    else
+	return wc + 64;
+}
+#endif
+
+/* c is a multibyte control character.  It displays as ^@, ^?, or ^[ch],
+ * where ch is (c + 64).  We return that multibyte character.  If crep
+ * is an invalid multibyte sequence, it will be replaced with Unicode
+ * 0xFFFD (Replacement Character). */
+char *control_mbrep(const char *c, char *crep, int *crep_len)
+{
+    assert(c != NULL && crep != NULL && crep_len != NULL);
+
+#ifdef ENABLE_UTF8
+    if (use_utf8) {
+	wchar_t wc;
+
+	if (mbtowc(&wc, c, MB_CUR_MAX) < 0) {
+	    mbtowc_reset();
+	    *crep_len = bad_mbchar_len;
+	    strncpy(crep, bad_mbchar, *crep_len);
+	} else {
+	    *crep_len = wctomb(crep, control_wrep(wc));
+
+	    if (*crep_len < 0) {
+		wctomb_reset();
+		*crep_len = 0;
+	    }
+	}
+    } else {
+#endif
+	*crep_len = 1;
+	*crep = control_rep(*c);
+#ifdef ENABLE_UTF8
+    }
+#endif
+
+    return crep;
+}
+
+/* c is a multibyte non-control character.  We return that multibyte
+ * character.  If crep is an invalid multibyte sequence, it will be
+ * replaced with Unicode 0xFFFD (Replacement Character). */
+char *mbrep(const char *c, char *crep, int *crep_len)
+{
+    assert(c != NULL && crep != NULL && crep_len != NULL);
+
+#ifdef ENABLE_UTF8
+    if (use_utf8) {
+	wchar_t wc;
+
+	/* Reject invalid Unicode characters. */
+	if (mbtowc(&wc, c, MB_CUR_MAX) < 0 || !is_valid_unicode(wc)) {
+	    mbtowc_reset();
+	    *crep_len = bad_mbchar_len;
+	    strncpy(crep, bad_mbchar, *crep_len);
+	} else {
+	    *crep_len = wctomb(crep, wc);
+
+	    if (*crep_len < 0) {
+		wctomb_reset();
+		*crep_len = 0;
+	    }
+	}
+    } else {
+#endif
+	*crep_len = 1;
+	*crep = *c;
+#ifdef ENABLE_UTF8
+    }
+#endif
+
+    return crep;
+}
+
+/* This function is equivalent to wcwidth() for multibyte characters. */
+int mbwidth(const char *c)
+{
+    assert(c != NULL);
+
+#ifdef ENABLE_UTF8
+    if (use_utf8) {
+	wchar_t wc;
+	int width;
+
+	if (mbtowc(&wc, c, MB_CUR_MAX) < 0) {
+	    mbtowc_reset();
+	    wc = bad_wchar;
+	}
+
+	width = wcwidth(wc);
+
+	if (width == -1) {
+	    wc = bad_wchar;
+	    width = wcwidth(wc);
+	}
+
+	return width;
+    } else
+#endif
+	return 1;
+}
+
+/* Return the maximum width in bytes of a multibyte character. */
+int mb_cur_max(void)
+{
+    return
+#ifdef ENABLE_UTF8
+	use_utf8 ? MB_CUR_MAX :
+#endif
+	1;
+}
+
+/* Convert the Unicode value in chr to a multibyte character with the
+ * same wide character value as chr, if possible.  If the conversion
+ * succeeds, return the (dynamically allocated) multibyte character and
+ * its length.  Otherwise, return an undefined (dynamically allocated)
+ * multibyte character and a length of zero. */
+char *make_mbchar(long chr, int *chr_mb_len)
+{
+    char *chr_mb;
+
+    assert(chr_mb_len != NULL);
+
+#ifdef ENABLE_UTF8
+    if (use_utf8) {
+	chr_mb = charalloc(MB_CUR_MAX);
+	*chr_mb_len = wctomb(chr_mb, (wchar_t)chr);
+
+	/* Reject invalid Unicode characters. */
+	if (*chr_mb_len < 0 || !is_valid_unicode((wchar_t)chr)) {
+	    wctomb_reset();
+	    *chr_mb_len = 0;
+	}
+    } else {
+#endif
+	*chr_mb_len = 1;
+	chr_mb = mallocstrncpy(NULL, (char *)&chr, 1);
+#ifdef ENABLE_UTF8
+    }
+#endif
+
+    return chr_mb;
+}
+
+/* Parse a multibyte character from buf.  Return the number of bytes
+ * used.  If chr isn't NULL, store the multibyte character in it.  If
+ * col isn't NULL, store the new display width in it.  If *buf is '\t',
+ * we expect col to have the current display width. */
+int parse_mbchar(const char *buf, char *chr, size_t *col)
+{
+    int buf_mb_len;
+
+    assert(buf != NULL);
+
+#ifdef ENABLE_UTF8
+    if (use_utf8) {
+	/* Get the number of bytes in the multibyte character. */
+	buf_mb_len = mblen(buf, MB_CUR_MAX);
+
+	/* If buf contains an invalid multibyte character, only
+	 * interpret buf's first byte. */
+	if (buf_mb_len < 0) {
+	    IGNORE_CALL_RESULT(mblen(NULL, 0));
+	    buf_mb_len = 1;
+	} else if (buf_mb_len == 0)
+	    buf_mb_len++;
+
+	/* Save the multibyte character in chr. */
+	if (chr != NULL) {
+	    int i;
+
+	    for (i = 0; i < buf_mb_len; i++)
+		chr[i] = buf[i];
+	}
+
+	/* Save the column width of the wide character in col. */
+	if (col != NULL) {
+	    /* If we have a tab, get its width in columns using the
+	     * current value of col. */
+	    if (*buf == '\t')
+		*col += tabsize - *col % tabsize;
+	    /* If we have a control character, get its width using one
+	     * column for the "^" that will be displayed in front of it,
+	     * and the width in columns of its visible equivalent as
+	     * returned by control_mbrep(). */
+	    else if (is_cntrl_mbchar(buf)) {
+		char *ctrl_buf_mb = charalloc(MB_CUR_MAX);
+		int ctrl_buf_mb_len;
+
+		(*col)++;
+
+		ctrl_buf_mb = control_mbrep(buf, ctrl_buf_mb,
+			&ctrl_buf_mb_len);
+
+		*col += mbwidth(ctrl_buf_mb);
+
+		free(ctrl_buf_mb);
+	    /* If we have a normal character, get its width in columns
+	     * normally. */
+	    } else
+		*col += mbwidth(buf);
+	}
+    } else {
+#endif
+	/* Get the number of bytes in the byte character. */
+	buf_mb_len = 1;
+
+	/* Save the byte character in chr. */
+	if (chr != NULL)
+	    *chr = *buf;
+
+	if (col != NULL) {
+	    /* If we have a tab, get its width in columns using the
+	     * current value of col. */
+	    if (*buf == '\t')
+		*col += tabsize - *col % tabsize;
+	    /* If we have a control character, it's two columns wide:
+	     * one column for the "^" that will be displayed in front of
+	     * it, and one column for its visible equivalent as returned
+	     * by control_mbrep(). */
+	    else if (is_cntrl_char((unsigned char)*buf))
+		*col += 2;
+	    /* If we have a normal character, it's one column wide. */
+	    else
+		(*col)++;
+	}
+#ifdef ENABLE_UTF8
+    }
+#endif
+
+    return buf_mb_len;
+}
+
+/* Return the index in buf of the beginning of the multibyte character
+ * before the one at pos. */
+size_t move_mbleft(const char *buf, size_t pos)
+{
+    size_t pos_prev = pos;
+
+    assert(buf != NULL && pos <= strlen(buf));
+
+    /* There is no library function to move backward one multibyte
+     * character.  Here is the naive, O(pos) way to do it. */
+    while (TRUE) {
+	int buf_mb_len = parse_mbchar(buf + pos - pos_prev, NULL, NULL);
+
+	if (pos_prev <= buf_mb_len)
+	    break;
+
+	pos_prev -= buf_mb_len;
+    }
+
+    return pos - pos_prev;
+}
+
+/* Return the index in buf of the beginning of the multibyte character
+ * after the one at pos. */
+size_t move_mbright(const char *buf, size_t pos)
+{
+    return pos + parse_mbchar(buf + pos, NULL, NULL);
+}
+
+#ifndef HAVE_STRCASECMP
+/* This function is equivalent to strcasecmp(). */
+int nstrcasecmp(const char *s1, const char *s2)
+{
+    return strncasecmp(s1, s2, (size_t)-1);
+}
+#endif
+
+/* This function is equivalent to strcasecmp() for multibyte strings. */
+int mbstrcasecmp(const char *s1, const char *s2)
+{
+    return mbstrncasecmp(s1, s2, (size_t)-1);
+}
+
+#ifndef HAVE_STRNCASECMP
+/* This function is equivalent to strncasecmp(). */
+int nstrncasecmp(const char *s1, const char *s2, size_t n)
+{
+    if (s1 == s2)
+	return 0;
+
+    assert(s1 != NULL && s2 != NULL);
+
+    for (; *s1 != '\0' && *s2 != '\0' && n > 0; s1++, s2++, n--) {
+	if (tolower(*s1) != tolower(*s2))
+	    break;
+    }
+
+    return (n > 0) ? tolower(*s1) - tolower(*s2) : 0;
+}
+#endif
+
+/* This function is equivalent to strncasecmp() for multibyte
+ * strings. */
+int mbstrncasecmp(const char *s1, const char *s2, size_t n)
+{
+#ifdef ENABLE_UTF8
+    if (use_utf8) {
+	char *s1_mb, *s2_mb;
+	wchar_t ws1, ws2;
+
+	if (s1 == s2)
+	    return 0;
+
+	assert(s1 != NULL && s2 != NULL);
+
+	s1_mb = charalloc(MB_CUR_MAX);
+	s2_mb = charalloc(MB_CUR_MAX);
+
+	for (; *s1 != '\0' && *s2 != '\0' && n > 0; s1 +=
+		move_mbright(s1, 0), s2 += move_mbright(s2, 0), n--) {
+	    bool bad_s1_mb = FALSE, bad_s2_mb = FALSE;
+	    int s1_mb_len, s2_mb_len;
+
+	    s1_mb_len = parse_mbchar(s1, s1_mb, NULL);
+
+	    if (mbtowc(&ws1, s1_mb, s1_mb_len) < 0) {
+		mbtowc_reset();
+		ws1 = (unsigned char)*s1_mb;
+		bad_s1_mb = TRUE;
+	    }
+
+	    s2_mb_len = parse_mbchar(s2, s2_mb, NULL);
+
+	    if (mbtowc(&ws2, s2_mb, s2_mb_len) < 0) {
+		mbtowc_reset();
+		ws2 = (unsigned char)*s2_mb;
+		bad_s2_mb = TRUE;
+	    }
+
+	    if (bad_s1_mb != bad_s2_mb || towlower(ws1) !=
+		towlower(ws2))
+		break;
+	}
+
+	free(s1_mb);
+	free(s2_mb);
+
+	return (n > 0) ? towlower(ws1) - towlower(ws2) : 0;
+    } else
+#endif
+	return strncasecmp(s1, s2, n);
+}
+
+#ifndef HAVE_STRCASESTR
+/* This function is equivalent to strcasestr(). */
+char *nstrcasestr(const char *haystack, const char *needle)
+{
+    size_t haystack_len, needle_len;
+
+    assert(haystack != NULL && needle != NULL);
+
+    if (*needle == '\0')
+	return (char *)haystack;
+
+    haystack_len = strlen(haystack);
+    needle_len = strlen(needle);
+
+    for (; *haystack != '\0' && haystack_len >= needle_len; haystack++,
+	haystack_len--) {
+	if (strncasecmp(haystack, needle, needle_len) == 0)
+	    return (char *)haystack;
+    }
+
+    return NULL;
+}
+#endif
+
+/* This function is equivalent to strcasestr() for multibyte strings. */
+char *mbstrcasestr(const char *haystack, const char *needle)
+{
+#ifdef ENABLE_UTF8
+    if (use_utf8) {
+	size_t haystack_len, needle_len;
+
+	assert(haystack != NULL && needle != NULL);
+
+	if (*needle == '\0')
+	    return (char *)haystack;
+
+	haystack_len = mbstrlen(haystack);
+	needle_len = mbstrlen(needle);
+
+	for (; *haystack != '\0' && haystack_len >= needle_len;
+		haystack += move_mbright(haystack, 0), haystack_len--) {
+	    if (mbstrncasecmp(haystack, needle, needle_len) == 0)
+		return (char *)haystack;
+	}
+
+	return NULL;
+    } else
+#endif
+	return (char *) strcasestr(haystack, needle);
+}
+
+#if !defined(NANO_TINY) || !defined(DISABLE_TABCOMP)
+/* This function is equivalent to strstr(), except in that it scans the
+ * string in reverse, starting at rev_start. */
+char *revstrstr(const char *haystack, const char *needle, const char
+	*rev_start)
+{
+    size_t rev_start_len, needle_len;
+
+    assert(haystack != NULL && needle != NULL && rev_start != NULL);
+
+    if (*needle == '\0')
+	return (char *)rev_start;
+
+    needle_len = strlen(needle);
+
+    if (strlen(haystack) < needle_len)
+	return NULL;
+
+    rev_start_len = strlen(rev_start);
+
+    for (; rev_start >= haystack; rev_start--, rev_start_len++) {
+	if (rev_start_len >= needle_len && strncmp(rev_start, needle,
+		needle_len) == 0)
+	    return (char *)rev_start;
+    }
+
+    return NULL;
+}
+#endif /* !NANO_TINY || !DISABLE_TABCOMP */
+
+#ifndef NANO_TINY
+/* This function is equivalent to strcasestr(), except in that it scans
+ * the string in reverse, starting at rev_start. */
+char *revstrcasestr(const char *haystack, const char *needle, const char
+	*rev_start)
+{
+    size_t rev_start_len, needle_len;
+
+    assert(haystack != NULL && needle != NULL && rev_start != NULL);
+
+    if (*needle == '\0')
+	return (char *)rev_start;
+
+    needle_len = strlen(needle);
+
+    if (strlen(haystack) < needle_len)
+	return NULL;
+
+    rev_start_len = strlen(rev_start);
+
+    for (; rev_start >= haystack; rev_start--, rev_start_len++) {
+	if (rev_start_len >= needle_len && strncasecmp(rev_start,
+		needle, needle_len) == 0)
+	    return (char *)rev_start;
+    }
+
+    return NULL;
+}
+
+/* This function is equivalent to strcasestr() for multibyte strings,
+ * except in that it scans the string in reverse, starting at
+ * rev_start. */
+char *mbrevstrcasestr(const char *haystack, const char *needle, const
+	char *rev_start)
+{
+#ifdef ENABLE_UTF8
+    if (use_utf8) {
+	bool begin_line = FALSE;
+	size_t rev_start_len, needle_len;
+
+	assert(haystack != NULL && needle != NULL && rev_start != NULL);
+
+	if (*needle == '\0')
+	    return (char *)rev_start;
+
+	needle_len = mbstrlen(needle);
+
+	if (mbstrlen(haystack) < needle_len)
+	    return NULL;
+
+	rev_start_len = mbstrlen(rev_start);
+
+	while (!begin_line) {
+	    if (rev_start_len >= needle_len && mbstrncasecmp(rev_start,
+		needle, needle_len) == 0)
+		return (char *)rev_start;
+
+	    if (rev_start == haystack)
+		begin_line = TRUE;
+	    else {
+		rev_start = haystack + move_mbleft(haystack, rev_start -
+			haystack);
+		rev_start_len++;
+	    }
+	}
+
+	return NULL;
+    } else
+#endif
+	return revstrcasestr(haystack, needle, rev_start);
+}
+#endif /* !NANO_TINY */
+
+/* This function is equivalent to strlen() for multibyte strings. */
+size_t mbstrlen(const char *s)
+{
+    return mbstrnlen(s, (size_t)-1);
+}
+
+#ifndef HAVE_STRNLEN
+/* This function is equivalent to strnlen(). */
+size_t nstrnlen(const char *s, size_t maxlen)
+{
+    size_t n = 0;
+
+    assert(s != NULL);
+
+    for (; *s != '\0' && maxlen > 0; s++, maxlen--, n++)
+	;
+
+    return n;
+}
+#endif
+
+/* This function is equivalent to strnlen() for multibyte strings. */
+size_t mbstrnlen(const char *s, size_t maxlen)
+{
+    assert(s != NULL);
+
+#ifdef ENABLE_UTF8
+    if (use_utf8) {
+	size_t n = 0;
+
+	for (; *s != '\0' && maxlen > 0; s += move_mbright(s, 0),
+		maxlen--, n++)
+	    ;
+
+	return n;
+    } else
+#endif
+	return strnlen(s, maxlen);
+}
+
+#if !defined(NANO_TINY) || !defined(DISABLE_JUSTIFY)
+/* This function is equivalent to strchr() for multibyte strings. */
+char *mbstrchr(const char *s, const char *c)
+{
+    assert(s != NULL && c != NULL);
+
+#ifdef ENABLE_UTF8
+    if (use_utf8) {
+	bool bad_s_mb = FALSE, bad_c_mb = FALSE;
+	char *s_mb = charalloc(MB_CUR_MAX);
+	const char *q = s;
+	wchar_t ws, wc;
+	int c_mb_len = mbtowc(&wc, c, MB_CUR_MAX);
+
+	if (c_mb_len < 0) {
+	    mbtowc_reset();
+	    wc = (unsigned char)*c;
+	    bad_c_mb = TRUE;
+	}
+
+	while (*s != '\0') {
+	    int s_mb_len = parse_mbchar(s, s_mb, NULL);
+
+	    if (mbtowc(&ws, s_mb, s_mb_len) < 0) {
+		mbtowc_reset();
+		ws = (unsigned char)*s;
+		bad_s_mb = TRUE;
+	    }
+
+	    if (bad_s_mb == bad_c_mb && ws == wc)
+		break;
+
+	    s += s_mb_len;
+	    q += s_mb_len;
+	}
+
+	free(s_mb);
+
+	if (*s == '\0')
+	    q = NULL;
+
+	return (char *)q;
+    } else
+#endif
+	return (char *) strchr(s, *c);
+}
+#endif /* !NANO_TINY || !DISABLE_JUSTIFY */
+
+#ifndef NANO_TINY
+/* This function is equivalent to strpbrk() for multibyte strings. */
+char *mbstrpbrk(const char *s, const char *accept)
+{
+    assert(s != NULL && accept != NULL);
+
+#ifdef ENABLE_UTF8
+    if (use_utf8) {
+	for (; *s != '\0'; s += move_mbright(s, 0)) {
+	    if (mbstrchr(accept, s) != NULL)
+		return (char *)s;
+	}
+
+	return NULL;
+    } else
+#endif
+	return (char *) strpbrk(s, accept);
+}
+
+/* This function is equivalent to strpbrk(), except in that it scans the
+ * string in reverse, starting at rev_start. */
+char *revstrpbrk(const char *s, const char *accept, const char
+	*rev_start)
+{
+    assert(s != NULL && accept != NULL && rev_start != NULL);
+
+    for (; rev_start >= s; rev_start--) {
+	const char *q = (*rev_start == '\0') ? NULL : strchr(accept,
+		*rev_start);
+
+	if (q != NULL)
+	    return (char *)rev_start;
+    }
+
+    return NULL;
+}
+
+/* This function is equivalent to strpbrk() for multibyte strings,
+ * except in that it scans the string in reverse, starting at
+ * rev_start. */
+char *mbrevstrpbrk(const char *s, const char *accept, const char
+	*rev_start)
+{
+    assert(s != NULL && accept != NULL && rev_start != NULL);
+
+#ifdef ENABLE_UTF8
+    if (use_utf8) {
+	bool begin_line = FALSE;
+
+	while (!begin_line) {
+	    const char *q = (*rev_start == '\0') ? NULL :
+		mbstrchr(accept, rev_start);
+
+	    if (q != NULL)
+		return (char *)rev_start;
+
+	    if (rev_start == s)
+		begin_line = TRUE;
+	    else
+		rev_start = s + move_mbleft(s, rev_start - s);
+	}
+
+	return NULL;
+    } else
+#endif
+	return revstrpbrk(s, accept, rev_start);
+}
+#endif /* !NANO_TINY */
+
+#if defined(ENABLE_NANORC) && (!defined(NANO_TINY) || !defined(DISABLE_JUSTIFY))
+/* Return TRUE if the string s contains one or more blank characters,
+ * and FALSE otherwise. */
+bool has_blank_chars(const char *s)
+{
+    assert(s != NULL);
+
+    for (; *s != '\0'; s++) {
+	if (isblank(*s))
+	    return TRUE;
+    }
+
+    return FALSE;
+}
+
+/* Return TRUE if the multibyte string s contains one or more blank
+ * multibyte characters, and FALSE otherwise. */
+bool has_blank_mbchars(const char *s)
+{
+    assert(s != NULL);
+
+#ifdef ENABLE_UTF8
+    if (use_utf8) {
+	bool retval = FALSE;
+	char *chr_mb = charalloc(MB_CUR_MAX);
+
+	for (; *s != '\0'; s += move_mbright(s, 0)) {
+	    parse_mbchar(s, chr_mb, NULL);
+
+	    if (is_blank_mbchar(chr_mb)) {
+		retval = TRUE;
+		break;
+	    }
+	}
+
+	free(chr_mb);
+
+	return retval;
+    } else
+#endif
+	return has_blank_chars(s);
+}
+#endif /* ENABLE_NANORC && (!NANO_TINY || !DISABLE_JUSTIFY) */
+
+#ifdef ENABLE_UTF8
+/* Return TRUE if wc is valid Unicode, and FALSE otherwise. */
+bool is_valid_unicode(wchar_t wc)
+{
+    return ((0 <= wc && wc <= 0x10FFFF) && (wc <= 0xD7FF || 0xE000 <=
+	wc) && (wc <= 0xFDCF || 0xFDF0 <= wc) && ((wc & 0xFFFF) <=
+	0xFFFD));
+}
+#endif
+
+#ifdef ENABLE_NANORC
+/* Check if the string s is a valid multibyte string.  Return TRUE if it
+ * is, and FALSE otherwise. */
+bool is_valid_mbstring(const char *s)
+{
+    assert(s != NULL);
+
+    return
+#ifdef ENABLE_UTF8
+	use_utf8 ? (mbstowcs(NULL, s, 0) != (size_t)-1) :
+#endif
+	TRUE;
+}
+#endif /* ENABLE_NANORC */
diff --git a/src/color.c b/src/color.c
new file mode 100644
index 0000000..e12efdd
--- /dev/null
+++ b/src/color.c
@@ -0,0 +1,431 @@
+/* $Id: color.c 4540 2011-03-05 05:01:13Z astyanax $ */
+/**************************************************************************
+ *   color.c                                                              *
+ *                                                                        *
+ *   Copyright (C) 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 <string.h>
+#include <errno.h>
+
+#ifdef HAVE_MAGIC_H
+#include <magic.h>
+#endif
+
+#ifdef ENABLE_COLOR
+
+/* For each syntax list entry, go through the list of colors and assign
+ * the color pairs. */
+void set_colorpairs(void)
+{
+    const syntaxtype *this_syntax = syntaxes;
+
+    for (; this_syntax != NULL; this_syntax = this_syntax->next) {
+	colortype *this_color = this_syntax->color;
+	int color_pair = 1;
+
+	for (; this_color != NULL; this_color = this_color->next) {
+	    const colortype *beforenow = this_syntax->color;
+
+	    for (; beforenow != this_color &&
+		(beforenow->fg != this_color->fg ||
+		beforenow->bg != this_color->bg ||
+		beforenow->bright != this_color->bright);
+		beforenow = beforenow->next)
+		;
+
+	    if (beforenow != this_color)
+		this_color->pairnum = beforenow->pairnum;
+	    else {
+		this_color->pairnum = color_pair;
+		color_pair++;
+	    }
+	}
+    }
+}
+
+/* Initialize the color information. */
+void color_init(void)
+{
+    assert(openfile != NULL);
+
+    if (has_colors()) {
+	const colortype *tmpcolor;
+#ifdef HAVE_USE_DEFAULT_COLORS
+	bool defok;
+#endif
+
+	start_color();
+
+#ifdef HAVE_USE_DEFAULT_COLORS
+	/* Use the default colors, if available. */
+	defok = (use_default_colors() != ERR);
+#endif
+
+	for (tmpcolor = openfile->colorstrings; tmpcolor != NULL;
+		tmpcolor = tmpcolor->next) {
+	    short foreground = tmpcolor->fg, background = tmpcolor->bg;
+	    if (foreground == -1) {
+#ifdef HAVE_USE_DEFAULT_COLORS
+		if (!defok)
+#endif
+		    foreground = COLOR_WHITE;
+	    }
+
+	    if (background == -1) {
+#ifdef HAVE_USE_DEFAULT_COLORS
+		if (!defok)
+#endif
+		    background = COLOR_BLACK;
+	    }
+
+	    init_pair(tmpcolor->pairnum, foreground, background);
+
+#ifdef DEBUG
+	    fprintf(stderr, "init_pair(): fg = %hd, bg = %hd\n", tmpcolor->fg, tmpcolor->bg);
+#endif
+	}
+    }
+}
+
+/* Cleanup a regex we previously compiled */
+void nfreeregex(regex_t **r)
+{
+    assert(r != NULL);
+
+    regfree(*r);
+    free(*r);
+    *r = NULL;
+}
+
+/* Update the color information based on the current filename. */
+void color_update(void)
+{
+    syntaxtype *tmpsyntax;
+    syntaxtype *defsyntax = NULL;
+    colortype *tmpcolor, *defcolor = NULL;
+    exttype *e;
+
+/* libmagic structures */
+/* magicstring will be NULL if we fail to get magic result */
+#ifdef HAVE_LIBMAGIC
+    const char *magicstring = NULL;
+    const char *magicerr = NULL;
+    magic_t m;
+    struct stat fileinfo;
+#endif /* HAVE_LIBMAGIC */
+
+
+    assert(openfile != NULL);
+
+    openfile->syntax = NULL;
+    openfile->colorstrings = NULL;
+
+    /* If we specified a syntax override string, use it. */
+    if (syntaxstr != NULL) {
+	/* If the syntax override is "none", it's the same as not having
+	 * a syntax at all, so get out. */
+	if (strcmp(syntaxstr, "none") == 0)
+	    return;
+
+	for (tmpsyntax = syntaxes; tmpsyntax != NULL;
+		tmpsyntax = tmpsyntax->next) {
+	    if (strcmp(tmpsyntax->desc, syntaxstr) == 0) {
+		openfile->syntax = tmpsyntax;
+		openfile->colorstrings = tmpsyntax->color;
+	    }
+
+	    if (openfile->colorstrings != NULL)
+		break;
+	}
+    }
+
+#ifdef HAVE_LIBMAGIC
+
+    if (strcmp(openfile->filename,"") && stat(openfile->filename, &fileinfo) == 0) {
+	m = magic_open(MAGIC_SYMLINK |
+#ifdef DEBUG
+                       MAGIC_DEBUG | MAGIC_CHECK |
+#endif /* DEBUG */
+                       MAGIC_ERROR);
+	if (m == NULL || magic_load(m, NULL) < 0)
+	    fprintf(stderr, "something went wrong: %s [%s]\n", strerror(errno), openfile->filename);
+	else {
+	    magicstring = magic_file(m,openfile->filename);
+	    if (magicstring == NULL) {
+		magicerr = magic_error(m);
+		fprintf(stderr, "something went wrong: %s [%s]\n", magicerr, openfile->filename);
+            }
+#ifdef DEBUG
+	    fprintf(stderr, "magic string returned: %s\n", magicstring);
+#endif /* DEBUG */
+	}
+    }
+#endif /* HAVE_LIBMAGIC */
+
+    /* If we didn't specify a syntax override string, or if we did and
+     * there was no syntax by that name, get the syntax based on the
+     * file extension, and then look in the header. */
+    if (openfile->colorstrings == NULL) {
+	for (tmpsyntax = syntaxes; tmpsyntax != NULL;
+		tmpsyntax = tmpsyntax->next) {
+
+	    /* If this is the default syntax, it has no associated
+	     * extensions, which we've checked for elsewhere.  Skip over
+	     * it here, but keep track of its color regexes. */
+	    if (strcmp(tmpsyntax->desc, "default") == 0) {
+		defsyntax = tmpsyntax;
+		defcolor = tmpsyntax->color;
+		continue;
+	    }
+
+	    for (e = tmpsyntax->extensions; e != NULL; e = e->next) {
+		bool not_compiled = (e->ext == NULL);
+
+		/* e->ext_regex has already been checked for validity
+		 * elsewhere.  Compile its specified regex if we haven't
+		 * already. */
+		if (not_compiled) {
+		    e->ext = (regex_t *)nmalloc(sizeof(regex_t));
+		    regcomp(e->ext, fixbounds(e->ext_regex), REG_EXTENDED);
+		}
+
+		/* Set colorstrings if we matched the extension
+		 * regex. */
+		if (regexec(e->ext, openfile->filename, 0, NULL, 0) == 0) {
+		    openfile->syntax = tmpsyntax;
+		    openfile->colorstrings = tmpsyntax->color;
+		    break;
+		}
+
+		/* Decompile e->ext_regex's specified regex if we aren't
+		 * going to use it. */
+		if (not_compiled)
+		    nfreeregex(&e->ext);
+	    }
+	}
+
+	    /* Check magic if we don't yet have an answer */
+#ifdef HAVE_LIBMAGIC
+	if (openfile->colorstrings == NULL) {
+
+#ifdef DEBUG
+	    fprintf(stderr, "No match using extension, trying libmagic...\n");
+#endif /* DEBUG */
+
+	    for (tmpsyntax = syntaxes; tmpsyntax != NULL;
+		tmpsyntax = tmpsyntax->next) {
+		for (e = tmpsyntax->magics; e != NULL; e = e->next) {
+		    bool not_compiled = (e->ext == NULL);
+		    if (not_compiled) {
+			e->ext = (regex_t *)nmalloc(sizeof(regex_t));
+			regcomp(e->ext, fixbounds(e->ext_regex), REG_EXTENDED);
+		    }
+#ifdef DEBUG
+		    fprintf(stderr,"Matching regex \"%s\" against \"%s\"\n",e->ext_regex, magicstring);
+#endif /* DEBUG */
+
+		    if (magicstring && regexec(e->ext, magicstring, 0, NULL, 0) == 0) {
+			openfile->syntax = tmpsyntax;
+			openfile->colorstrings = tmpsyntax->color;
+			break;
+		    }
+
+		    if (not_compiled)
+			nfreeregex(&e->ext);
+		}
+	    }
+	}
+#endif /* HAVE_LIBMAGIC */
+
+	/* If we haven't matched anything yet, try the headers */
+	if (openfile->colorstrings == NULL) {
+#ifdef DEBUG
+	    fprintf(stderr, "No match for file extensions, looking at headers...\n");
+#endif
+	    for (tmpsyntax = syntaxes; tmpsyntax != NULL;
+		tmpsyntax = tmpsyntax->next) {
+
+		for (e = tmpsyntax->headers; e != NULL; e = e->next) {
+		    bool not_compiled = (e->ext == NULL);
+
+		    /* e->ext_regex has already been checked for validity
+		     * elsewhere.  Compile its specified regex if we haven't
+		     * already. */
+		    if (not_compiled) {
+			e->ext = (regex_t *)nmalloc(sizeof(regex_t));
+			regcomp(e->ext, fixbounds(e->ext_regex), REG_EXTENDED);
+		    }
+
+		    /* Set colorstrings if we matched the extension
+		     * regex. */
+#ifdef DEBUG
+		fprintf(stderr, "Comparing header regex \"%s\" to fileage \"%s\"...\n", e->ext_regex, openfile->fileage->data);
+#endif
+		    if (regexec(e->ext, openfile->fileage->data, 0, NULL, 0) == 0) {
+			openfile->syntax = tmpsyntax;
+			openfile->colorstrings = tmpsyntax->color;
+		    }
+
+		    if (openfile->colorstrings != NULL)
+			break;
+
+		    /* Decompile e->ext_regex's specified regex if we aren't
+		     * going to use it. */
+		    if (not_compiled)
+			nfreeregex(&e->ext);
+		}
+	    }
+	}
+    }
+
+
+    /* If we didn't get a syntax based on the file extension, and we
+     * have a default syntax, use it. */
+    if (openfile->colorstrings == NULL && defcolor != NULL) {
+	openfile->syntax = defsyntax;
+	openfile->colorstrings = defcolor;
+    }
+
+    for (tmpcolor = openfile->colorstrings; tmpcolor != NULL;
+	tmpcolor = tmpcolor->next) {
+	/* tmpcolor->start_regex and tmpcolor->end_regex have already
+	 * been checked for validity elsewhere.  Compile their specified
+	 * regexes if we haven't already. */
+	if (tmpcolor->start == NULL) {
+	    tmpcolor->start = (regex_t *)nmalloc(sizeof(regex_t));
+	    regcomp(tmpcolor->start, fixbounds(tmpcolor->start_regex),
+		REG_EXTENDED | (tmpcolor->icase ? REG_ICASE : 0));
+	}
+
+	if (tmpcolor->end_regex != NULL && tmpcolor->end == NULL) {
+	    tmpcolor->end = (regex_t *)nmalloc(sizeof(regex_t));
+	    regcomp(tmpcolor->end, fixbounds(tmpcolor->end_regex),
+		REG_EXTENDED | (tmpcolor->icase ? REG_ICASE : 0));
+	}
+    }
+}
+
+/* Reset the multicolor info cache for records for any lines which need
+   to be recalculated */
+void reset_multis_after(filestruct *fileptr, int mindex)
+{
+    filestruct *oof;
+    for (oof = fileptr->next; oof != NULL; oof = oof->next) {
+	alloc_multidata_if_needed(oof);
+	if (oof->multidata == NULL)
+	    continue;
+	if (oof->multidata[mindex] != CNONE)
+	    oof->multidata[mindex] = -1;
+	else
+	    break;
+    }
+    for (; oof != NULL; oof = oof->next) {
+	alloc_multidata_if_needed(oof);
+	if (oof->multidata == NULL)
+	    continue;
+	if (oof->multidata[mindex] == CNONE)
+	    oof->multidata[mindex] = -1;
+	else
+	    break;
+    }
+    edit_refresh_needed = TRUE;
+}
+
+void reset_multis_before(filestruct *fileptr, int mindex)
+{
+    filestruct *oof;
+    for (oof = fileptr->prev; oof != NULL; oof = oof->prev) {
+	alloc_multidata_if_needed(oof);
+	if (oof->multidata == NULL)
+	    continue;
+	if (oof->multidata[mindex] != CNONE)
+	    oof->multidata[mindex] = -1;
+	else
+	    break;
+    }
+    for (; oof != NULL; oof = oof->prev) {
+	alloc_multidata_if_needed(oof);
+	if (oof->multidata == NULL)
+	    continue;
+	if (oof->multidata[mindex] == CNONE)
+	    oof->multidata[mindex] = -1;
+	else
+	    break;
+    }
+
+    edit_refresh_needed = TRUE;
+}
+
+/* Reset one multiline regex info */
+void reset_multis_for_id(filestruct *fileptr, int num)
+{
+    reset_multis_before(fileptr, num);
+    reset_multis_after(fileptr, num);
+    fileptr->multidata[num] = -1;
+}
+
+/* Reset multi line strings around a filestruct ptr, trying to be smart about stopping
+   force = reset everything regardless, useful when we don't know how much screen state
+           has changed  */
+void reset_multis(filestruct *fileptr, bool force)
+{
+    int nobegin, noend;
+    regmatch_t startmatch, endmatch;
+    const colortype *tmpcolor = openfile->colorstrings;
+
+    if (!openfile->syntax)
+	return;
+
+    for (; tmpcolor != NULL; tmpcolor = tmpcolor->next) {
+
+	/* If it's not a multi-line regex, amscray */
+	if (tmpcolor->end == NULL)
+	    continue;
+
+	alloc_multidata_if_needed(fileptr);
+	if (force == TRUE) {
+	    reset_multis_for_id(fileptr, tmpcolor->id);
+	    continue;
+	}
+
+	/* Figure out where the first begin and end are to determine if
+	   things changed drastically for the precalculated multi values */
+        nobegin = regexec(tmpcolor->start, fileptr->data, 1, &startmatch, 0);
+        noend = regexec(tmpcolor->end, fileptr->data, 1, &endmatch, 0);
+	if (fileptr->multidata[tmpcolor->id] ==  CWHOLELINE) {
+	    if (nobegin && noend)
+		continue;
+	} else if (fileptr->multidata[tmpcolor->id] == CNONE) {
+	    if (nobegin && noend)
+		continue;
+	}  else if (fileptr->multidata[tmpcolor->id] & CBEGINBEFORE && !noend
+	  && (nobegin || endmatch.rm_eo > startmatch.rm_eo)) {
+	    reset_multis_after(fileptr, tmpcolor->id);
+	    continue;
+	}
+
+	/* If we got here assume the worst */
+	reset_multis_for_id(fileptr, tmpcolor->id);
+    }
+}
+#endif /* ENABLE_COLOR */
diff --git a/src/cut.c b/src/cut.c
new file mode 100644
index 0000000..8c21c8e
--- /dev/null
+++ b/src/cut.c
@@ -0,0 +1,291 @@
+/* $Id: cut.c 4453 2009-12-02 03:36:22Z astyanax $ */
+/**************************************************************************
+ *   cut.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 <string.h>
+#include <stdio.h>
+
+static bool keep_cutbuffer = FALSE;
+	/* Should we keep the contents of the cutbuffer? */
+	/* Pointer to the end of the cutbuffer. */
+
+/* Indicate that we should no longer keep the contents of the
+ * cutbuffer. */
+void cutbuffer_reset(void)
+{
+    keep_cutbuffer = FALSE;
+}
+
+/* If we aren't on the last line of the file, move all the text of the
+ * current line, plus the newline at the end, into the cutbuffer.  If we
+ * are, move all of the text of the current line into the cutbuffer.  In
+ * both cases, set the current place we want to the beginning of the
+ * current line. */
+void cut_line(void)
+{
+    if (openfile->current != openfile->filebot)
+	move_to_filestruct(&cutbuffer, &cutbottom, openfile->current, 0,
+		openfile->current->next, 0);
+    else
+	move_to_filestruct(&cutbuffer, &cutbottom, openfile->current, 0,
+		openfile->current, strlen(openfile->current->data));
+    openfile->placewewant = 0;
+}
+
+#ifndef NANO_TINY
+/* Move all currently marked text into the cutbuffer, and set the
+ * current place we want to where the text used to start. */
+void cut_marked(void)
+{
+    filestruct *top, *bot;
+    size_t top_x, bot_x;
+
+    mark_order((const filestruct **)&top, &top_x,
+	(const filestruct **)&bot, &bot_x, NULL);
+
+    move_to_filestruct(&cutbuffer, &cutbottom, top, top_x, bot, bot_x);
+    openfile->placewewant = xplustabs();
+}
+
+/* If we aren't at the end of the current line, move all the text from
+ * the current cursor position to the end of the current line, not
+ * counting the newline at the end, into the cutbuffer.  If we are, and
+ * we're not on the last line of the file, move the newline at the end
+ * into the cutbuffer, and set the current place we want to where the
+ * newline used to be. */
+void cut_to_eol(void)
+{
+    size_t data_len = strlen(openfile->current->data);
+
+    assert(openfile->current_x <= data_len);
+
+    if (openfile->current_x < data_len)
+	/* If we're not at the end of the line, move all the text from
+	 * the current position up to it, not counting the newline at
+	 * the end, into the cutbuffer. */
+	move_to_filestruct(&cutbuffer, &cutbottom, openfile->current,
+		openfile->current_x, openfile->current, data_len);
+    else if (openfile->current != openfile->filebot) {
+	/* If we're at the end of the line, and it isn't the last line
+	 * of the file, move all the text from the current position up
+	 * to the beginning of the next line, i.e. the newline at the
+	 * end, into the cutbuffer. */
+	move_to_filestruct(&cutbuffer, &cutbottom, openfile->current,
+		openfile->current_x, openfile->current->next, 0);
+	openfile->placewewant = xplustabs();
+    }
+}
+
+/* Move all the text from the current cursor position to the end of the
+ * file into the cutbuffer. */
+void cut_to_eof(void)
+{
+    move_to_filestruct(&cutbuffer, &cutbottom, openfile->current,
+	openfile->current_x, openfile->filebot,
+	strlen(openfile->filebot->data));
+}
+#endif /* !NANO_TINY */
+
+/* Move text from the current filestruct into the cutbuffer.  If
+ * copy_text is TRUE, copy the text back into the filestruct afterward.
+ * If cut_till_end is TRUE, move all text from the current cursor
+ * position to the end of the file into the cutbuffer. */
+void do_cut_text(
+#ifndef NANO_TINY
+	bool copy_text, bool cut_till_end, bool undoing
+#else
+	void
+#endif
+	)
+{
+#ifndef NANO_TINY
+    filestruct *cb_save = NULL;
+	/* The current end of the cutbuffer, before we add text to
+	 * it. */
+    size_t cb_save_len = 0;
+	/* The length of the string at the current end of the cutbuffer,
+	 * before we add text to it.  */
+    bool old_no_newlines = ISSET(NO_NEWLINES);
+#endif
+
+    assert(openfile->current != NULL && openfile->current->data != NULL);
+
+    /* If keep_cutbuffer is FALSE and the cutbuffer isn't empty, blow
+     * away the text in the cutbuffer. */
+    if (!keep_cutbuffer && cutbuffer != NULL) {
+	free_filestruct(cutbuffer);
+	cutbuffer = NULL;
+#ifdef DEBUG
+	fprintf(stderr, "Blew away cutbuffer =)\n");
+#endif
+    }
+
+#ifndef NANO_TINY
+    if (copy_text) {
+	if (cutbuffer != NULL) {
+	    /* If the cutbuffer isn't empty, save where it currently
+	     * ends.  This is where we'll add the new text. */
+	    cb_save = cutbottom;
+	    cb_save_len = strlen(cutbottom->data);
+	}
+
+	/* Set NO_NEWLINES to TRUE, so that we don't disturb the last
+	 * line of the file when moving text to the cutbuffer. */
+	SET(NO_NEWLINES);
+    }
+#endif
+
+    /* Set keep_cutbuffer to TRUE, so that the text we're going to move
+     * into the cutbuffer will be added to the text already in the
+     * cutbuffer instead of replacing it. */
+    keep_cutbuffer = TRUE;
+
+#ifndef NANO_TINY
+
+    if (cut_till_end) {
+	/* If cut_till_end is TRUE, move all text up to the end of the
+	 * file into the cutbuffer. */
+	cut_to_eof();
+    } else if (openfile->mark_set) {
+	/* If the mark is on, move the marked text to the cutbuffer, and
+	 * turn the mark off. */
+	cut_marked();
+	openfile->mark_set = FALSE;
+    } else if (ISSET(CUT_TO_END))
+	/* If the CUT_TO_END flag is set, move all text up to the end of
+	 * the line into the cutbuffer. */
+	cut_to_eol();
+    else
+#endif
+	/* Move the entire line into the cutbuffer. */
+	cut_line();
+
+#ifndef NANO_TINY
+    if (copy_text) {
+	/* Copy the text in the cutbuffer, starting at its saved end if
+	 * there is one, back into the filestruct.  This effectively
+	 * uncuts the text we just cut without marking the file as
+	 * modified. */
+	if (cutbuffer != NULL) {
+	    if (cb_save != NULL) {
+		cb_save->data += cb_save_len;
+		copy_from_filestruct(cb_save, cutbottom);
+		cb_save->data -= cb_save_len;
+	    } else
+		copy_from_filestruct(cutbuffer, cutbottom);
+
+	    /* Set the current place we want to where the text from the
+	     * cutbuffer ends. */
+	    openfile->placewewant = xplustabs();
+	}
+
+	/* Set NO_NEWLINES back to what it was before, since we're done
+	 * disturbing the text. */
+	if (!old_no_newlines)
+	    UNSET(NO_NEWLINES);
+    } else if (!undoing)
+	update_undo(CUT);
+#endif
+	/* Leave the text in the cutbuffer, and mark the file as
+	 * modified. */
+	set_modified();
+
+    /* Update the screen. */
+    edit_refresh_needed = TRUE;
+
+#ifdef ENABLE_COLOR
+    reset_multis(openfile->current, FALSE);
+#endif
+
+#ifdef DEBUG
+    dump_filestruct(cutbuffer);
+#endif
+}
+
+/* Move text from the current filestruct into the cutbuffer. */
+void do_cut_text_void(void)
+{
+#ifndef NANO_TINY
+    add_undo(CUT);
+#endif
+    do_cut_text(
+#ifndef NANO_TINY
+	FALSE, FALSE, FALSE
+#endif
+	);
+}
+
+#ifndef NANO_TINY
+/* Move text from the current filestruct into the cutbuffer, and copy it
+ * back into the filestruct afterward. */
+void do_copy_text(void)
+{
+    do_cut_text(TRUE, FALSE, FALSE);
+}
+
+/* Cut from the current cursor position to the end of the file. */
+void do_cut_till_end(void)
+{
+#ifndef NANO_TINY
+    add_undo(CUT);
+#endif
+    do_cut_text(FALSE, TRUE, FALSE);
+}
+#endif /* !NANO_TINY */
+
+/* Copy text from the cutbuffer into the current filestruct. */
+void do_uncut_text(void)
+{
+    assert(openfile->current != NULL && openfile->current->data != NULL);
+
+    /* If the cutbuffer is empty, get out. */
+    if (cutbuffer == NULL)
+	return;
+
+#ifndef NANO_TINY
+     update_undo(UNCUT);
+#endif
+
+    /* Add a copy of the text in the cutbuffer to the current filestruct
+     * at the current cursor position. */
+    copy_from_filestruct(cutbuffer, cutbottom);
+
+    /* Set the current place we want to where the text from the
+     * cutbuffer ends. */
+    openfile->placewewant = xplustabs();
+
+    /* Mark the file as modified. */
+    set_modified();
+
+    /* Update the screen. */
+    edit_refresh_needed = TRUE;
+
+#ifdef ENABLE_COLOR
+    reset_multis(openfile->current, FALSE);
+#endif
+
+#ifdef DEBUG
+    dump_filestruct_reverse();
+#endif
+}
diff --git a/src/files.c b/src/files.c
new file mode 100644
index 0000000..f6efbf1
--- /dev/null
+++ b/src/files.c
@@ -0,0 +1,3041 @@
+/* $Id: files.c 4534 2011-02-24 02:47:25Z astyanax $ */
+/**************************************************************************
+ *   files.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 <string.h>
+#include <unistd.h>
+#include <utime.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <ctype.h>
+#include <pwd.h>
+
+/* Add an entry to the openfile openfilestruct.  This should only be
+ * called from open_buffer(). */
+void make_new_buffer(void)
+{
+    /* If there are no entries in openfile, make the first one and
+     * move to it. */
+    if (openfile == NULL) {
+	openfile = make_new_opennode();
+	splice_opennode(openfile, openfile, openfile);
+    /* Otherwise, make a new entry for openfile, splice it in after
+     * the current entry, and move to it. */
+    } else {
+	splice_opennode(openfile, make_new_opennode(), openfile->next);
+	openfile = openfile->next;
+    }
+
+    /* Initialize the new buffer. */
+    initialize_buffer();
+}
+
+/* Initialize the current entry of the openfile openfilestruct. */
+void initialize_buffer(void)
+{
+    assert(openfile != NULL);
+
+    openfile->filename = mallocstrcpy(NULL, "");
+
+    initialize_buffer_text();
+
+    openfile->current_x = 0;
+    openfile->placewewant = 0;
+    openfile->current_y = 0;
+
+    openfile->modified = FALSE;
+#ifndef NANO_TINY
+    openfile->mark_set = FALSE;
+
+    openfile->mark_begin = NULL;
+    openfile->mark_begin_x = 0;
+
+    openfile->fmt = NIX_FILE;
+
+    openfile->current_stat = NULL;
+    openfile->undotop = NULL;
+    openfile->current_undo = NULL;
+#endif
+#ifdef ENABLE_COLOR
+    openfile->colorstrings = NULL;
+#endif
+}
+
+/* Initialize the text of the current entry of the openfile
+ * openfilestruct. */
+void initialize_buffer_text(void)
+{
+    assert(openfile != NULL);
+
+    openfile->fileage = make_new_node(NULL);
+    openfile->fileage->data = mallocstrcpy(NULL, "");
+
+    openfile->filebot = openfile->fileage;
+    openfile->edittop = openfile->fileage;
+    openfile->current = openfile->fileage;
+
+#ifdef ENABLE_COLOR
+    openfile->fileage->multidata = NULL;
+#endif
+
+    openfile->totsize = 0;
+}
+
+/* If it's not "", filename is a file to open.  We make a new buffer, if
+ * necessary, and then open and read the file, if applicable. */
+void open_buffer(const char *filename, bool undoable)
+{
+    bool new_buffer = (openfile == NULL
+#ifdef ENABLE_MULTIBUFFER
+	 || ISSET(MULTIBUFFER)
+#endif
+	);
+	/* Whether we load into this buffer or a new one. */
+    FILE *f;
+    int rc;
+	/* rc == -2 means that we have a new file.  -1 means that the
+	 * open() failed.  0 means that the open() succeeded. */
+
+    assert(filename != NULL);
+
+#ifndef DISABLE_OPERATINGDIR
+    if (check_operating_dir(filename, FALSE)) {
+	statusbar(_("Can't insert file from outside of %s"),
+		operating_dir);
+	return;
+    }
+#endif
+
+    /* If the filename isn't blank, open the file.  Otherwise, treat it
+     * as a new file. */
+    rc = (filename[0] != '\0') ? open_file(filename, new_buffer, &f) :
+	-2;
+
+    /* If we're loading into a new buffer, add a new entry to
+     * openfile. */
+    if (new_buffer)
+	make_new_buffer();
+
+    /* If we have a file, and we're loading into a new buffer, update
+     * the filename. */
+    if (rc != -1 && new_buffer)
+	openfile->filename = mallocstrcpy(openfile->filename, filename);
+
+    /* If we have a non-new file, read it in.  Then, if the buffer has
+     * no stat, update the stat, if applicable. */
+    if (rc > 0) {
+	read_file(f, rc, filename, undoable, new_buffer);
+#ifndef NANO_TINY
+	if (openfile->current_stat == NULL) {
+	    openfile->current_stat =
+		(struct stat *)nmalloc(sizeof(struct stat));
+	    stat(filename, openfile->current_stat);
+	}
+#endif
+    }
+
+    /* If we have a file, and we're loading into a new buffer, move back
+     * to the beginning of the first line of the buffer. */
+    if (rc != -1 && new_buffer) {
+	openfile->current = openfile->fileage;
+	openfile->current_x = 0;
+	openfile->placewewant = 0;
+    }
+
+#ifdef ENABLE_COLOR
+    /* If we're loading into a new buffer, update the colors to account
+     * for it, if applicable. */
+    if (new_buffer)
+	color_update();
+#endif
+}
+
+#ifndef DISABLE_SPELLER
+/* If it's not "", filename is a file to open.  We blow away the text of
+ * the current buffer, and then open and read the file, if
+ * applicable.  Note that we skip the operating directory test when
+ * doing this. */
+void replace_buffer(const char *filename)
+{
+    FILE *f;
+    int rc;
+	/* rc == -2 means that we have a new file.  -1 means that the
+	 * open() failed.  0 means that the open() succeeded. */
+
+    assert(filename != NULL);
+
+    /* If the filename isn't blank, open the file.  Otherwise, treat it
+     * as a new file. */
+    rc = (filename[0] != '\0') ? open_file(filename, TRUE, &f) : -2;
+
+    /* Reinitialize the text of the current buffer. */
+    free_filestruct(openfile->fileage);
+    initialize_buffer_text();
+
+    /* If we have a non-new file, read it in. */
+    if (rc > 0)
+	read_file(f, rc, filename, FALSE, TRUE);
+
+    /* Move back to the beginning of the first line of the buffer. */
+    openfile->current = openfile->fileage;
+    openfile->current_x = 0;
+    openfile->placewewant = 0;
+}
+#endif /* !DISABLE_SPELLER */
+
+/* Update the screen to account for the current buffer. */
+void display_buffer(void)
+{
+    /* Update the titlebar, since the filename may have changed. */
+    titlebar(NULL);
+
+#ifdef ENABLE_COLOR
+    /* Make sure we're using the buffer's associated colors, if
+     * applicable. */
+    color_init();
+#endif
+
+    /* Update the edit window. */
+    edit_refresh();
+}
+
+#ifdef ENABLE_MULTIBUFFER
+/* Switch to the next file buffer if next_buf is TRUE.  Otherwise,
+ * switch to the previous file buffer. */
+void switch_to_prevnext_buffer(bool next_buf)
+{
+    assert(openfile != NULL);
+
+    /* If only one file buffer is open, indicate it on the statusbar and
+     * get out. */
+    if (openfile == openfile->next) {
+	statusbar(_("No more open file buffers"));
+	return;
+    }
+
+    /* Switch to the next or previous file buffer, depending on the
+     * value of next_buf. */
+    openfile = next_buf ? openfile->next : openfile->prev;
+
+#ifdef DEBUG
+    fprintf(stderr, "filename is %s\n", openfile->filename);
+#endif
+
+    /* Update the screen to account for the current buffer. */
+    display_buffer();
+
+    /* Indicate the switch on the statusbar. */
+    statusbar(_("Switched to %s"),
+	((openfile->filename[0] == '\0') ? _("New Buffer") :
+	openfile->filename));
+
+#ifdef DEBUG
+    dump_filestruct(openfile->current);
+#endif
+}
+
+/* Switch to the previous entry in the openfile filebuffer. */
+void switch_to_prev_buffer_void(void)
+{
+    switch_to_prevnext_buffer(FALSE);
+}
+
+/* Switch to the next entry in the openfile filebuffer. */
+void switch_to_next_buffer_void(void)
+{
+    switch_to_prevnext_buffer(TRUE);
+}
+
+/* Delete an entry from the openfile filebuffer, and switch to the one
+ * after it.  Return TRUE on success, or FALSE if there are no more open
+ * file buffers. */
+bool close_buffer(void)
+{
+    assert(openfile != NULL);
+
+    /* If only one file buffer is open, get out. */
+    if (openfile == openfile->next)
+	return FALSE;
+
+#ifndef NANO_TINY
+        update_poshistory(openfile->filename, openfile->current->lineno, xplustabs()+1);
+#endif /* NANO_TINY */
+
+    /* Switch to the next file buffer. */
+    switch_to_next_buffer_void();
+
+    /* Close the file buffer we had open before. */
+    unlink_opennode(openfile->prev);
+
+    display_main_list();
+
+    return TRUE;
+}
+#endif /* ENABLE_MULTIBUFFER */
+
+/* A bit of a copy and paste from open_file(), is_file_writable()
+ * just checks whether the file is appendable as a quick
+ * permissions check, and we tend to err on the side of permissiveness
+ * (reporting TRUE when it might be wrong) to not fluster users
+ * editing on odd filesystems by printing incorrect warnings.
+ */
+int is_file_writable(const char *filename)
+{
+    struct stat fileinfo, fileinfo2;
+    int fd;
+    FILE *f;
+    char *full_filename;
+    bool ans = TRUE;
+
+
+    if (ISSET(VIEW_MODE))
+	return TRUE;
+
+    assert(filename != NULL);
+
+    /* Get the specified file's full path. */
+    full_filename = get_full_path(filename);
+
+    /* Okay, if we can't stat the path due to a component's
+       permissions, just try the relative one */
+    if (full_filename == NULL
+        || (stat(full_filename, &fileinfo) == -1 && stat(filename, &fileinfo2) != -1))
+        full_filename = mallocstrcpy(NULL, filename);
+
+    if ((fd = open(full_filename, O_WRONLY | O_CREAT | O_APPEND, S_IRUSR |
+                S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)) == -1
+	|| (f = fdopen(fd, "a")) == NULL)
+	ans = FALSE;
+    else
+        fclose(f);
+    close(fd);
+
+    free(full_filename);
+    return ans;
+}
+
+/* We make a new line of text from buf.  buf is length buf_len.  If
+ * first_line_ins is TRUE, then we put the new line at the top of the
+ * file.  Otherwise, we assume prevnode is the last line of the file,
+ * and put our line after prevnode. */
+filestruct *read_line(char *buf, filestruct *prevnode, bool
+	*first_line_ins, size_t buf_len)
+{
+    filestruct *fileptr = (filestruct *)nmalloc(sizeof(filestruct));
+
+    /* Convert nulls to newlines.  buf_len is the string's real
+     * length. */
+    unsunder(buf, buf_len);
+
+    assert(openfile->fileage != NULL && strlen(buf) == buf_len);
+
+    fileptr->data = mallocstrcpy(NULL, buf);
+
+#ifndef NANO_TINY
+    /* If it's a DOS file ("\r\n"), and file conversion isn't disabled,
+     * strip the '\r' part from fileptr->data. */
+    if (!ISSET(NO_CONVERT) && buf_len > 0 && buf[buf_len - 1] == '\r')
+	fileptr->data[buf_len - 1] = '\0';
+#endif
+
+#ifdef ENABLE_COLOR
+	fileptr->multidata = NULL;
+#endif
+
+    if (*first_line_ins) {
+	/* Special case: We're inserting with the cursor on the first
+	 * line. */
+	fileptr->prev = NULL;
+	fileptr->next = openfile->fileage;
+	fileptr->lineno = 1;
+	if (*first_line_ins) {
+	    *first_line_ins = FALSE;
+	    /* If we're inserting into the first line of the file, then
+	     * we want to make sure that our edit buffer stays on the
+	     * first line and that fileage stays up to date. */
+	    openfile->edittop = fileptr;
+	} else
+	    openfile->filebot = fileptr;
+	openfile->fileage = fileptr;
+    } else {
+	assert(prevnode != NULL);
+
+	fileptr->prev = prevnode;
+	fileptr->next = NULL;
+	fileptr->lineno = prevnode->lineno + 1;
+	prevnode->next = fileptr;
+    }
+
+    return fileptr;
+}
+
+/* Read an open file into the current buffer.  f should be set to the
+ * open file, and filename should be set to the name of the file.
+ * undoable  means do we want to create undo records to try and undo this.
+ * Will also attempt to check file writability if fd > 0 and checkwritable == TRUE
+ */
+void read_file(FILE *f, int fd, const char *filename, bool undoable, bool checkwritable)
+{
+    size_t num_lines = 0;
+	/* The number of lines in the file. */
+    size_t len = 0;
+	/* The length of the current line of the file. */
+    size_t i = 0;
+	/* The position in the current line of the file. */
+    size_t bufx = MAX_BUF_SIZE;
+	/* The size of each chunk of the file that we read. */
+    char input = '\0';
+	/* The current input character. */
+    char *buf;
+	/* The buffer where we store chunks of the file. */
+    filestruct *fileptr = openfile->current;
+	/* The current line of the file. */
+    bool first_line_ins = FALSE;
+	/* Whether we're inserting with the cursor on the first line. */
+    int input_int;
+	/* The current value we read from the file, whether an input
+	 * character or EOF. */
+    bool writable = TRUE;
+	/* Is the file writable (if we care) */
+#ifndef NANO_TINY
+    int format = 0;
+	/* 0 = *nix, 1 = DOS, 2 = Mac, 3 = both DOS and Mac. */
+#endif
+
+    assert(openfile->fileage != NULL && openfile->current != NULL);
+
+    buf = charalloc(bufx);
+    buf[0] = '\0';
+
+#ifndef NANO_TINY
+    if (undoable)
+	add_undo(INSERT);
+#endif
+
+    if (openfile->current == openfile->fileage)
+	first_line_ins = TRUE;
+    else
+	fileptr = openfile->current->prev;
+
+    /* Read the entire file into the filestruct. */
+    while ((input_int = getc(f)) != EOF) {
+	input = (char)input_int;
+
+	/* If it's a *nix file ("\n") or a DOS file ("\r\n"), and file
+	 * conversion isn't disabled, handle it! */
+	if (input == '\n') {
+#ifndef NANO_TINY
+	    /* If it's a DOS file or a DOS/Mac file ('\r' before '\n' on
+	     * the first line if we think it's a *nix file, or on any
+	     * line otherwise), and file conversion isn't disabled,
+	     * handle it! */
+	    if (!ISSET(NO_CONVERT) && (num_lines == 0 || format != 0) &&
+		i > 0 && buf[i - 1] == '\r') {
+		if (format == 0 || format == 2)
+		    format++;
+	    }
+#endif
+
+	    /* Read in the line properly. */
+	    fileptr = read_line(buf, fileptr, &first_line_ins, len);
+
+	    /* Reset the line length in preparation for the next
+	     * line. */
+	    len = 0;
+
+	    num_lines++;
+	    buf[0] = '\0';
+	    i = 0;
+#ifndef NANO_TINY
+	/* If it's a Mac file ('\r' without '\n' on the first line if we
+	 * think it's a *nix file, or on any line otherwise), and file
+	 * conversion isn't disabled, handle it! */
+	} else if (!ISSET(NO_CONVERT) && (num_lines == 0 ||
+		format != 0) && i > 0 && buf[i - 1] == '\r') {
+	    /* If we currently think the file is a *nix file, set format
+	     * to Mac.  If we currently think the file is a DOS file,
+	     * set format to both DOS and Mac. */
+	    if (format == 0 || format == 1)
+		format += 2;
+
+	    /* Read in the line properly. */
+	    fileptr = read_line(buf, fileptr, &first_line_ins, len);
+
+	    /* Reset the line length in preparation for the next line.
+	     * Since we've already read in the next character, reset it
+	     * to 1 instead of 0. */
+	    len = 1;
+
+	    num_lines++;
+	    buf[0] = input;
+	    buf[1] = '\0';
+	    i = 1;
+#endif
+	} else {
+	    /* Calculate the total length of the line.  It might have
+	     * nulls in it, so we can't just use strlen() here. */
+	    len++;
+
+	    /* Now we allocate a bigger buffer MAX_BUF_SIZE characters
+	     * at a time.  If we allocate a lot of space for one line,
+	     * we may indeed have to use a buffer this big later on, so
+	     * we don't decrease it at all.  We do free it at the end,
+	     * though. */
+	    if (i >= bufx - 1) {
+		bufx += MAX_BUF_SIZE;
+		buf = charealloc(buf, bufx);
+	    }
+
+	    buf[i] = input;
+	    buf[i + 1] = '\0';
+	    i++;
+	}
+    }
+
+    /* Perhaps this could use some better handling. */
+    if (ferror(f))
+	nperror(filename);
+    fclose(f);
+    if (fd > 0 && checkwritable) {
+	close(fd);
+	writable = is_file_writable(filename);
+    }
+
+#ifndef NANO_TINY
+    /* If file conversion isn't disabled and the last character in this
+     * file is '\r', read it in properly as a Mac format line. */
+    if (len == 0 && !ISSET(NO_CONVERT) && input == '\r') {
+	len = 1;
+
+	buf[0] = input;
+	buf[1] = '\0';
+    }
+#endif
+
+    /* Did we not get a newline and still have stuff to do? */
+    if (len > 0) {
+#ifndef NANO_TINY
+	/* If file conversion isn't disabled and the last character in
+	 * this file is '\r', set format to Mac if we currently think
+	 * the file is a *nix file, or to both DOS and Mac if we
+	 * currently think the file is a DOS file. */
+	if (!ISSET(NO_CONVERT) && buf[len - 1] == '\r' &&
+		(format == 0 || format == 1))
+	    format += 2;
+#endif
+
+	/* Read in the last line properly. */
+	fileptr = read_line(buf, fileptr, &first_line_ins, len);
+	num_lines++;
+    }
+
+    free(buf);
+
+    /* If we didn't get a file and we don't already have one, open a
+     * blank buffer. */
+    if (fileptr == NULL)
+	open_buffer("", FALSE);
+
+    /* Attach the file we got to the filestruct.  If we got a file of
+     * zero bytes, don't do anything. */
+    if (num_lines > 0) {
+	/* If the file we got doesn't end in a newline, tack its last
+	 * line onto the beginning of the line at current. */
+	if (len > 0) {
+	    size_t current_len = strlen(openfile->current->data);
+
+	    /* Adjust the current x-coordinate to compensate for the
+	     * change in the current line. */
+	    if (num_lines == 1)
+		openfile->current_x += len;
+	    else
+		openfile->current_x = len;
+
+	    /* Tack the text at fileptr onto the beginning of the text
+	     * at current. */
+	    openfile->current->data =
+		charealloc(openfile->current->data, len +
+		current_len + 1);
+	    charmove(openfile->current->data + len,
+		openfile->current->data, current_len + 1);
+	    strncpy(openfile->current->data, fileptr->data, len);
+
+	    /* Don't destroy fileage, edittop, or filebot! */
+	    if (fileptr == openfile->fileage)
+		openfile->fileage = openfile->current;
+	    if (fileptr == openfile->edittop)
+		openfile->edittop = openfile->current;
+	    if (fileptr == openfile->filebot)
+		openfile->filebot = openfile->current;
+
+	    /* Move fileptr back one line and blow away the old fileptr,
+	     * since its text has been saved. */
+	    fileptr = fileptr->prev;
+	    if (fileptr != NULL) {
+		if (fileptr->next != NULL)
+		    free(fileptr->next);
+	    }
+	}
+
+	/* Attach the line at current after the line at fileptr. */
+	if (fileptr != NULL) {
+	    fileptr->next = openfile->current;
+	    openfile->current->prev = fileptr;
+	}
+
+	/* Renumber starting with the last line of the file we
+	 * inserted. */
+	renumber(openfile->current);
+    }
+
+    openfile->totsize += get_totsize(openfile->fileage,
+	openfile->filebot);
+
+    /* If the NO_NEWLINES flag isn't set, and text has been added to
+     * the magicline (i.e. a file that doesn't end in a newline has been
+     * inserted at the end of the current buffer), add a new magicline,
+     * and move the current line down to it. */
+    if (!ISSET(NO_NEWLINES) && openfile->filebot->data[0] != '\0') {
+	new_magicline();
+	openfile->current = openfile->filebot;
+	openfile->current_x = 0;
+    }
+
+    /* Set the current place we want to the end of the last line of the
+     * file we inserted. */
+    openfile->placewewant = xplustabs();
+
+#ifndef NANO_TINY
+    if (undoable)
+	update_undo(INSERT);
+
+    if (format == 3) {
+	if (writable)
+	    statusbar(
+		P_("Read %lu line (Converted from DOS and Mac format)",
+		"Read %lu lines (Converted from DOS and Mac format)",
+		(unsigned long)num_lines), (unsigned long)num_lines);
+	else
+	    statusbar(
+		P_("Read %lu line (Converted from DOS and Mac format - Warning: No write permission)",
+		"Read %lu lines (Converted from DOS and Mac format - Warning: No write permission)",
+		(unsigned long)num_lines), (unsigned long)num_lines);
+    } else if (format == 2) {
+	openfile->fmt = MAC_FILE;
+	if (writable)
+	    statusbar(P_("Read %lu line (Converted from Mac format)",
+		"Read %lu lines (Converted from Mac format)",
+		(unsigned long)num_lines), (unsigned long)num_lines);
+	else
+	    statusbar(P_("Read %lu line (Converted from Mac format - Warning: No write permission)",
+		"Read %lu lines (Converted from Mac format - Warning: No write permission)",
+		(unsigned long)num_lines), (unsigned long)num_lines);
+    } else if (format == 1) {
+	openfile->fmt = DOS_FILE;
+	if (writable)
+	    statusbar(P_("Read %lu line (Converted from DOS format)",
+		"Read %lu lines (Converted from DOS format)",
+		(unsigned long)num_lines), (unsigned long)num_lines);
+	else
+	    statusbar(P_("Read %lu line (Converted from DOS format - Warning: No write permission)",
+		"Read %lu lines (Converted from DOS format - Warning: No write permission)",
+		(unsigned long)num_lines), (unsigned long)num_lines);
+    } else
+#endif
+	if (writable)
+	    statusbar(P_("Read %lu line", "Read %lu lines",
+		(unsigned long)num_lines), (unsigned long)num_lines);
+	else
+	    statusbar(P_("Read %lu line ( Warning: No write permission)",
+		"Read %lu lines (Warning: No write permission)",
+		(unsigned long)num_lines), (unsigned long)num_lines);
+}
+
+/* Open the file (and decide if it exists).  If newfie is TRUE, display
+ * "New File" if the file is missing.  Otherwise, say "[filename] not
+ * found".
+ *
+ * Return -2 if we say "New File", -1 if the file isn't opened, and the
+ * fd opened otherwise.  The file might still have an error while reading 
+ * with a 0 return value.  *f is set to the opened file. */
+int open_file(const char *filename, bool newfie, FILE **f)
+{
+    struct stat fileinfo, fileinfo2;
+    int fd;
+    char *full_filename;
+
+    assert(filename != NULL && f != NULL);
+
+    /* Get the specified file's full path. */
+    full_filename = get_full_path(filename);
+
+    /* Okay, if we can't stat the path due to a component's
+       permissions, just try the relative one */
+    if (full_filename == NULL 
+	|| (stat(full_filename, &fileinfo) == -1 && stat(filename, &fileinfo2) != -1))
+	full_filename = mallocstrcpy(NULL, filename);
+
+    if (stat(full_filename, &fileinfo) == -1) {
+	/* Well, maybe we can open the file even if the OS
+	   says its not there */
+        if ((fd = open(filename, O_RDONLY)) != -1) {
+	    statusbar(_("Reading File"));
+	    free(full_filename);
+	    return 0;
+	}
+
+	if (newfie) {
+	    statusbar(_("New File"));
+	    return -2;
+	}
+	statusbar(_("\"%s\" not found"), filename);
+	beep();
+	return -1;
+    } else if (S_ISDIR(fileinfo.st_mode) || S_ISCHR(fileinfo.st_mode) ||
+	S_ISBLK(fileinfo.st_mode)) {
+	/* Don't open directories, character files, or block files.
+	 * Sorry, /dev/sndstat! */
+	statusbar(S_ISDIR(fileinfo.st_mode) ?
+		_("\"%s\" is a directory") :
+		_("\"%s\" is a device file"), filename);
+	beep();
+	return -1;
+    } else if ((fd = open(full_filename, O_RDONLY)) == -1) {
+	statusbar(_("Error reading %s: %s"), filename,
+		strerror(errno));
+	beep();
+ 	return -1;
+     } else {
+	/* The file is A-OK.  Open it. */
+	*f = fdopen(fd, "rb");
+
+	if (*f == NULL) {
+	    statusbar(_("Error reading %s: %s"), filename,
+		strerror(errno));
+	    beep();
+	    close(fd);
+	} else
+	    statusbar(_("Reading File"));
+    }
+
+    free(full_filename);
+
+    return fd;
+}
+
+/* This function will return the name of the first available extension
+ * of a filename (starting with [name][suffix], then [name][suffix].1,
+ * etc.).  Memory is allocated for the return value.  If no writable
+ * extension exists, we return "". */
+char *get_next_filename(const char *name, const char *suffix)
+{
+    static int ulmax_digits = -1;
+    unsigned long i = 0;
+    char *buf;
+    size_t namelen, suffixlen;
+
+    assert(name != NULL && suffix != NULL);
+
+    if (ulmax_digits == -1)
+	ulmax_digits = digits(ULONG_MAX);
+
+    namelen = strlen(name);
+    suffixlen = strlen(suffix);
+
+    buf = charalloc(namelen + suffixlen + ulmax_digits + 2);
+    sprintf(buf, "%s%s", name, suffix);
+
+    while (TRUE) {
+	struct stat fs;
+
+	if (stat(buf, &fs) == -1)
+	    return buf;
+	if (i == ULONG_MAX)
+	    break;
+
+	i++;
+	sprintf(buf + namelen + suffixlen, ".%lu", i);
+    }
+
+    /* We get here only if there is no possible save file.  Blank out
+     * the filename to indicate this. */
+    null_at(&buf, 0);
+
+    return buf;
+}
+
+/* Insert a file into a new buffer if the MULTIBUFFER flag is set, or
+ * into the current buffer if it isn't.  If execute is TRUE, insert the
+ * output of an executed command instead of a file. */
+void do_insertfile(
+#ifndef NANO_TINY
+	bool execute
+#else
+	void
+#endif
+	)
+{
+    int i;
+    const char *msg;
+    char *ans = mallocstrcpy(NULL, "");
+	/* The last answer the user typed at the statusbar prompt. */
+    filestruct *edittop_save = openfile->edittop;
+    size_t current_x_save = openfile->current_x;
+    ssize_t current_y_save = openfile->current_y;
+    bool edittop_inside = FALSE, meta_key = FALSE, func_key = FALSE;
+    const sc *s;
+#ifndef NANO_TINY
+    bool right_side_up = FALSE, single_line = FALSE;
+#endif
+
+    currmenu = MINSERTFILE;
+
+    while (TRUE) {
+#ifndef NANO_TINY
+	if (execute) {
+	    msg =
+#ifdef ENABLE_MULTIBUFFER
+		ISSET(MULTIBUFFER) ?
+		_("Command to execute in new buffer [from %s] ") :
+#endif
+		_("Command to execute [from %s] ");
+	} else {
+#endif
+	    msg =
+#ifdef ENABLE_MULTIBUFFER
+		ISSET(MULTIBUFFER) ?
+		_("File to insert into new buffer [from %s] ") :
+#endif
+		_("File to insert [from %s] ");
+#ifndef NANO_TINY
+	}
+#endif
+
+	i = do_prompt(TRUE,
+#ifndef DISABLE_TABCOMP
+		TRUE,
+#endif
+#ifndef NANO_TINY
+		execute ? MEXTCMD :
+#endif
+		MINSERTFILE, ans,
+		&meta_key, &func_key,
+#ifndef NANO_TINY
+		NULL,
+#endif
+		edit_refresh, msg,
+#ifndef DISABLE_OPERATINGDIR
+		operating_dir != NULL && strcmp(operating_dir,
+		".") != 0 ? operating_dir :
+#endif
+		"./");
+
+	/* If we're in multibuffer mode and the filename or command is
+	 * blank, open a new buffer instead of canceling.  If the
+	 * filename or command begins with a newline (i.e. an encoded
+	 * null), treat it as though it's blank. */
+	if (i == -1 || ((i == -2 || *answer == '\n')
+#ifdef ENABLE_MULTIBUFFER
+		&& !ISSET(MULTIBUFFER)
+#endif
+		)) {
+	    statusbar(_("Cancelled"));
+	    break;
+	} else {
+	    size_t pww_save = openfile->placewewant;
+
+	    ans = mallocstrcpy(ans, answer);
+
+	    s = get_shortcut(currmenu, &i, &meta_key, &func_key);
+
+#ifndef NANO_TINY
+#ifdef ENABLE_MULTIBUFFER
+
+	    if (s && s->scfunc == new_buffer_void) {
+		/* Don't allow toggling if we're in view mode. */
+		if (!ISSET(VIEW_MODE))
+		    TOGGLE(MULTIBUFFER);
+		continue;
+	    } else
+#endif
+	    if (s && s->scfunc == ext_cmd_void) {
+		execute = !execute;
+		continue;
+	    }
+#ifndef DISABLE_BROWSER
+	    else
+#endif
+#endif /* !NANO_TINY */
+
+#ifndef DISABLE_BROWSER
+	    if (s && s->scfunc == to_files_void) {
+		char *tmp = do_browse_from(answer);
+
+		if (tmp == NULL)
+		    continue;
+
+		/* We have a file now.  Indicate this. */
+		free(answer);
+		answer = tmp;
+
+		i = 0;
+	    }
+#endif
+
+	    /* If we don't have a file yet, go back to the statusbar
+	     * prompt. */
+	    if (i != 0
+#ifdef ENABLE_MULTIBUFFER
+		&& (i != -2 || !ISSET(MULTIBUFFER))
+#endif
+		)
+		continue;
+
+#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
+
+#ifdef ENABLE_MULTIBUFFER
+	    if (!ISSET(MULTIBUFFER)) {
+#endif
+		/* If we're not inserting into a new buffer, partition
+		 * the filestruct so that it contains no text and hence
+		 * looks like a new buffer, and keep track of whether
+		 * the top of the edit window is inside the
+		 * partition. */
+		filepart = partition_filestruct(openfile->current,
+			openfile->current_x, openfile->current,
+			openfile->current_x);
+		edittop_inside =
+			(openfile->edittop == openfile->fileage);
+#ifdef ENABLE_MULTIBUFFER
+	    }
+#endif
+
+	    /* Convert newlines to nulls, just before we insert the file
+	     * or execute the command. */
+	    sunder(answer);
+	    align(&answer);
+
+#ifndef NANO_TINY
+	    if (execute) {
+#ifdef ENABLE_MULTIBUFFER
+		if (ISSET(MULTIBUFFER))
+		    /* Open a blank buffer. */
+		    open_buffer("", FALSE);
+#endif
+
+		/* Save the command's output in the current buffer. */
+		execute_command(answer);
+
+#ifdef ENABLE_MULTIBUFFER
+		if (ISSET(MULTIBUFFER)) {
+		    /* Move back to the beginning of the first line of
+		     * the buffer. */
+		    openfile->current = openfile->fileage;
+		    openfile->current_x = 0;
+		    openfile->placewewant = 0;
+		}
+#endif
+	    } else {
+#endif /* !NANO_TINY */
+		/* Make sure the path to the file specified in answer is
+		 * tilde-expanded. */
+		answer = mallocstrassn(answer,
+			real_dir_from_tilde(answer));
+
+		/* Save the file specified in answer in the current
+		 * buffer. */
+		open_buffer(answer, TRUE);
+#ifndef NANO_TINY
+	    }
+#endif
+
+#ifdef ENABLE_MULTIBUFFER
+	    if (ISSET(MULTIBUFFER))
+		/* Update the screen to account for the current
+		 * buffer. */
+		display_buffer();
+	    else
+#endif
+	    {
+		filestruct *top_save = openfile->fileage;
+
+		/* If we were at the top of the edit window before, set
+		 * the saved value of edittop to the new top of the edit
+		 * window. */
+		if (edittop_inside)
+		    edittop_save = openfile->fileage;
+
+		/* Update the current x-coordinate to account for the
+		 * number of characters inserted on the current line.
+		 * If the mark begins inside the partition, adjust the
+		 * mark coordinates to compensate for the change in the
+		 * current line. */
+		openfile->current_x = strlen(openfile->filebot->data);
+		if (openfile->fileage == openfile->filebot) {
+#ifndef NANO_TINY
+		    if (openfile->mark_set) {
+			openfile->mark_begin = openfile->current;
+			if (!right_side_up)
+			    openfile->mark_begin_x +=
+				openfile->current_x;
+		    }
+#endif
+		    openfile->current_x += current_x_save;
+		}
+#ifndef NANO_TINY
+		else if (openfile->mark_set) {
+		    if (!right_side_up) {
+			if (single_line) {
+			    openfile->mark_begin = openfile->current;
+			    openfile->mark_begin_x -= current_x_save;
+			} else
+			    openfile->mark_begin_x -=
+				openfile->current_x;
+		    }
+		}
+#endif
+
+		/* Update the current y-coordinate to account for the
+		 * number of lines inserted. */
+		openfile->current_y += current_y_save;
+
+		/* Unpartition the filestruct so that it contains all
+		 * the text again.  Note that we've replaced the
+		 * non-text originally in the partition with the text in
+		 * the inserted file/executed command output. */
+		unpartition_filestruct(&filepart);
+
+		/* Renumber starting with the beginning line of the old
+		 * partition. */
+		renumber(top_save);
+
+		/* Restore the old edittop. */
+		openfile->edittop = edittop_save;
+
+		/* Restore the old place we want. */
+		openfile->placewewant = pww_save;
+
+		/* Mark the file as modified. */
+		set_modified();
+
+		/* Update the screen. */
+		edit_refresh();
+	    }
+
+	    break;
+	}
+    }
+    shortcut_init(FALSE);
+
+    free(ans);
+}
+
+/* Insert a file into a new buffer or the current buffer, depending on
+ * whether the MULTIBUFFER flag is set.  If we're in view mode, only
+ * allow inserting a file into a new buffer. */
+void do_insertfile_void(void)
+{
+
+    if (ISSET(RESTRICTED)) {
+        nano_disabled_msg();
+	return;
+    }
+
+#ifdef ENABLE_MULTIBUFFER
+    if (ISSET(VIEW_MODE) && !ISSET(MULTIBUFFER))
+	statusbar(_("Key invalid in non-multibuffer mode"));
+    else
+#endif
+	do_insertfile(
+#ifndef NANO_TINY
+		FALSE
+#endif
+		);
+
+    display_main_list();
+}
+
+/* When passed "[relative path]" or "[relative path][filename]" in
+ * origpath, return "[full path]" or "[full path][filename]" on success,
+ * or NULL on error.  Do this if the file doesn't exist but the relative
+ * path does, since the file could exist in memory but not yet on disk).
+ * Don't do this if the relative path doesn't exist, since we won't be
+ * able to go there. */
+char *get_full_path(const char *origpath)
+{
+    struct stat fileinfo;
+    char *d_here, *d_there, *d_there_file = NULL;
+    const char *last_slash;
+    bool path_only;
+
+    if (origpath == NULL)
+    	return NULL;
+
+    /* Get the current directory.  If it doesn't exist, back up and try
+     * again until we get a directory that does, and use that as the
+     * current directory. */
+    d_here = charalloc(PATH_MAX + 1);
+    d_here = getcwd(d_here, PATH_MAX + 1);
+
+    while (d_here == NULL) {
+	if (chdir("..") == -1)
+	    break;
+
+	d_here = getcwd(d_here, PATH_MAX + 1);
+    }
+
+    /* If we succeeded, canonicalize it in d_here. */
+    if (d_here != NULL) {
+	align(&d_here);
+
+	/* If the current directory isn't "/", tack a slash onto the end
+	 * of it. */
+	if (strcmp(d_here, "/") != 0) {
+	    d_here = charealloc(d_here, strlen(d_here) + 2);
+	    strcat(d_here, "/");
+	}
+    /* Otherwise, set d_here to "". */
+    } else
+	d_here = mallocstrcpy(NULL, "");
+
+    d_there = real_dir_from_tilde(origpath);
+
+    /* If stat()ing d_there fails, assume that d_there refers to a new
+     * file that hasn't been saved to disk yet.  Set path_only to TRUE
+     * if d_there refers to a directory, and FALSE otherwise. */
+    path_only = (stat(d_there, &fileinfo) != -1 &&
+	S_ISDIR(fileinfo.st_mode));
+
+    /* If path_only is TRUE, make sure d_there ends in a slash. */
+    if (path_only) {
+	size_t d_there_len = strlen(d_there);
+
+	if (d_there[d_there_len - 1] != '/') {
+	    d_there = charealloc(d_there, d_there_len + 2);
+	    strcat(d_there, "/");
+	}
+    }
+
+    /* Search for the last slash in d_there. */
+    last_slash = strrchr(d_there, '/');
+
+    /* If we didn't find one, then make sure the answer is in the format
+     * "d_here/d_there". */
+    if (last_slash == NULL) {
+	assert(!path_only);
+
+	d_there_file = d_there;
+	d_there = d_here;
+    } else {
+	/* If path_only is FALSE, then save the filename portion of the
+	 * answer (everything after the last slash) in d_there_file. */
+	if (!path_only)
+	    d_there_file = mallocstrcpy(NULL, last_slash + 1);
+
+	/* Remove the filename portion of the answer from d_there. */
+	null_at(&d_there, last_slash - d_there + 1);
+
+	/* Go to the path specified in d_there. */
+	if (chdir(d_there) == -1) {
+	    free(d_there);
+	    d_there = NULL;
+	} else {
+	    free(d_there);
+
+	    /* Get the full path. */
+	    d_there = charalloc(PATH_MAX + 1);
+	    d_there = getcwd(d_there, PATH_MAX + 1);
+
+	    /* If we succeeded, canonicalize it in d_there. */
+	    if (d_there != NULL) {
+		align(&d_there);
+
+		/* If the current directory isn't "/", tack a slash onto
+		 * the end of it. */
+		if (strcmp(d_there, "/") != 0) {
+		    d_there = charealloc(d_there, strlen(d_there) + 2);
+		    strcat(d_there, "/");
+		}
+	    } else
+		/* Otherwise, set path_only to TRUE, so that we clean up
+		 * correctly, free all allocated memory, and return
+		 * NULL. */
+		path_only = TRUE;
+
+	    /* Finally, go back to the path specified in d_here,
+	     * where we were before.  We don't check for a chdir()
+	     * error, since we can do nothing if we get one. */
+	    IGNORE_CALL_RESULT(chdir(d_here));
+
+	    /* Free d_here, since we're done using it. */
+	    free(d_here);
+	}
+    }
+
+    /* At this point, if path_only is FALSE and d_there isn't NULL,
+     * d_there contains the path portion of the answer and d_there_file
+     * contains the filename portion of the answer.  If this is the
+     * case, tack the latter onto the end of the former.  d_there will
+     * then contain the complete answer. */
+    if (!path_only && d_there != NULL) {
+	d_there = charealloc(d_there, strlen(d_there) +
+		strlen(d_there_file) + 1);
+	strcat(d_there, d_there_file);
+    }
+
+    /* Free d_there_file, since we're done using it. */
+    if (d_there_file != NULL)
+	free(d_there_file);
+
+    return d_there;
+}
+
+/* Return the full version of path, as returned by get_full_path().  On
+ * error, if path doesn't reference a directory, or if the directory
+ * isn't writable, return NULL. */
+char *check_writable_directory(const char *path)
+{
+    char *full_path = get_full_path(path);
+
+    /* If get_full_path() fails, return NULL. */
+    if (full_path == NULL)
+	return NULL;
+
+    /* If we can't write to path or path isn't a directory, return
+     * NULL. */
+    if (access(full_path, W_OK) != 0 ||
+	full_path[strlen(full_path) - 1] != '/') {
+	free(full_path);
+	return NULL;
+    }
+
+    /* Otherwise, return the full path. */
+    return full_path;
+}
+
+/* This function calls mkstemp(($TMPDIR|P_tmpdir|/tmp/)"nano.XXXXXX").
+ * On success, it returns the malloc()ed filename and corresponding FILE
+ * stream, opened in "r+b" mode.  On error, it returns NULL for the
+ * filename and leaves the FILE stream unchanged. */
+char *safe_tempfile(FILE **f)
+{
+    char *full_tempdir = NULL;
+    const char *tmpdir_env;
+    int fd;
+    mode_t original_umask = 0;
+
+    assert(f != NULL);
+
+    /* If $TMPDIR is set, set tempdir to it, run it through
+     * get_full_path(), and save the result in full_tempdir.  Otherwise,
+     * leave full_tempdir set to NULL. */
+    tmpdir_env = getenv("TMPDIR");
+    if (tmpdir_env != NULL)
+	full_tempdir = check_writable_directory(tmpdir_env);
+
+    /* If $TMPDIR is unset, empty, or not a writable directory, and
+     * full_tempdir is NULL, try P_tmpdir instead. */
+    if (full_tempdir == NULL)
+	full_tempdir = check_writable_directory(P_tmpdir);
+
+    /* if P_tmpdir is NULL, use /tmp. */
+    if (full_tempdir == NULL)
+	full_tempdir = mallocstrcpy(NULL, "/tmp/");
+
+    full_tempdir = charealloc(full_tempdir, strlen(full_tempdir) + 12);
+    strcat(full_tempdir, "nano.XXXXXX");
+
+    original_umask = umask(0);
+    umask(S_IRWXG | S_IRWXO);
+
+    fd = mkstemp(full_tempdir);
+
+    if (fd != -1)
+	*f = fdopen(fd, "r+b");
+    else {
+	free(full_tempdir);
+	full_tempdir = NULL;
+    }
+
+    umask(original_umask);
+
+    return full_tempdir;
+}
+
+#ifndef DISABLE_OPERATINGDIR
+/* Initialize full_operating_dir based on operating_dir. */
+void init_operating_dir(void)
+{
+    assert(full_operating_dir == NULL);
+
+    if (operating_dir == NULL)
+	return;
+
+    full_operating_dir = get_full_path(operating_dir);
+
+    /* If get_full_path() failed or the operating directory is
+     * inaccessible, unset operating_dir. */
+    if (full_operating_dir == NULL || chdir(full_operating_dir) == -1) {
+	free(full_operating_dir);
+	full_operating_dir = NULL;
+	free(operating_dir);
+	operating_dir = NULL;
+    }
+}
+
+/* Check to see if we're inside the operating directory.  Return FALSE
+ * if we are, or TRUE otherwise.  If allow_tabcomp is TRUE, allow
+ * incomplete names that would be matches for the operating directory,
+ * so that tab completion will work. */
+bool check_operating_dir(const char *currpath, bool allow_tabcomp)
+{
+    /* full_operating_dir is global for memory cleanup.  It should have
+     * already been initialized by init_operating_dir().  Also, a
+     * relative operating directory path will only be handled properly
+     * if this is done. */
+
+    char *fullpath;
+    bool retval = FALSE;
+    const char *whereami1, *whereami2 = NULL;
+
+    /* If no operating directory is set, don't bother doing anything. */
+    if (operating_dir == NULL)
+	return FALSE;
+
+    assert(full_operating_dir != NULL);
+
+    fullpath = get_full_path(currpath);
+
+    /* If fullpath is NULL, it means some directory in the path doesn't
+     * exist or is unreadable.  If allow_tabcomp is FALSE, then currpath
+     * is what the user typed somewhere.  We don't want to report a
+     * non-existent directory as being outside the operating directory,
+     * so we return FALSE.  If allow_tabcomp is TRUE, then currpath
+     * exists, but is not executable.  So we say it isn't in the
+     * operating directory. */
+    if (fullpath == NULL)
+	return allow_tabcomp;
+
+    whereami1 = strstr(fullpath, full_operating_dir);
+    if (allow_tabcomp)
+	whereami2 = strstr(full_operating_dir, fullpath);
+
+    /* If both searches failed, we're outside the operating directory.
+     * Otherwise, check the search results.  If the full operating
+     * directory path is not at the beginning of the full current path
+     * (for normal usage) and vice versa (for tab completion, if we're
+     * allowing it), we're outside the operating directory. */
+    if (whereami1 != fullpath && whereami2 != full_operating_dir)
+	retval = TRUE;
+    free(fullpath);
+
+    /* Otherwise, we're still inside it. */
+    return retval;
+}
+#endif
+
+#ifndef NANO_TINY
+/* Although this sucks, it sucks less than having a single 'my system is messed up
+ * and I'm blanket allowing insecure file writing operations.
+ */
+
+int prompt_failed_backupwrite(const char *filename)
+{
+    static int i;
+    static char *prevfile = NULL; /* What was the laast file we were paased so we don't keep asking this?
+                                     though maybe we should.... */
+    if (prevfile == NULL || strcmp(filename, prevfile)) {
+	i = do_yesno_prompt(FALSE,
+                         _("Failed to write backup file, continue saving? (Say N if unsure) "));
+	prevfile = mallocstrcpy(prevfile, filename);
+    }
+    return i;
+}
+
+void init_backup_dir(void)
+{
+    char *full_backup_dir;
+
+    if (backup_dir == NULL)
+	return;
+
+    full_backup_dir = get_full_path(backup_dir);
+
+    /* If get_full_path() failed or the backup directory is
+     * inaccessible, unset backup_dir. */
+    if (full_backup_dir == NULL ||
+	full_backup_dir[strlen(full_backup_dir) - 1] != '/') {
+	free(full_backup_dir);
+	free(backup_dir);
+	backup_dir = NULL;
+    } else {
+	free(backup_dir);
+	backup_dir = full_backup_dir;
+    }
+}
+#endif
+
+/* Read from inn, write to out.  We assume inn is opened for reading,
+ * and out for writing.  We return 0 on success, -1 on read error, or -2
+ * on write error. */
+int copy_file(FILE *inn, FILE *out)
+{
+    int retval = 0;
+    char buf[BUFSIZ];
+    size_t charsread;
+
+    assert(inn != NULL && out != NULL && inn != out);
+
+    do {
+	charsread = fread(buf, sizeof(char), BUFSIZ, inn);
+	if (charsread == 0 && ferror(inn)) {
+	    retval = -1;
+	    break;
+	}
+	if (fwrite(buf, sizeof(char), charsread, out) < charsread) {
+	    retval = -2;
+	    break;
+	}
+    } while (charsread > 0);
+
+    if (fclose(inn) == EOF)
+	retval = -1;
+    if (fclose(out) == EOF)
+	retval = -2;
+
+    return retval;
+}
+
+/* Write a file out to disk.  If f_open isn't NULL, we assume that it is
+ * a stream associated with the file, and we don't try to open it
+ * ourselves.  If tmp is TRUE, we set the umask to disallow anyone else
+ * from accessing the file, we don't set the filename to its name, and
+ * we don't print out how many lines we wrote on the statusbar.
+ *
+ * tmp means we are writing a temporary file in a secure fashion.  We
+ * use it when spell checking or dumping the file on an error.  If
+ * append is APPEND, it means we are appending instead of overwriting.
+ * If append is PREPEND, it means we are prepending instead of
+ * overwriting.  If nonamechange is TRUE, we don't change the current
+ * filename.  nonamechange is ignored if tmp is FALSE, we're appending,
+ * or we're prepending.
+ *
+ * Return TRUE on success or FALSE on error. */
+bool write_file(const char *name, FILE *f_open, bool tmp, append_type
+	append, bool nonamechange)
+{
+    bool retval = FALSE;
+	/* Instead of returning in this function, you should always
+	 * set retval and then goto cleanup_and_exit. */
+    size_t lineswritten = 0;
+    const filestruct *fileptr = openfile->fileage;
+    int fd;
+	/* The file descriptor we use. */
+    mode_t original_umask = 0;
+	/* Our umask, from when nano started. */
+    bool realexists;
+	/* The result of stat().  TRUE if the file exists, FALSE
+	 * otherwise.  If name is a link that points nowhere, realexists
+	 * is FALSE. */
+    struct stat st;
+	/* The status fields filled in by stat(). */
+    bool anyexists;
+	/* The result of lstat().  The same as realexists, unless name
+	 * is a link. */
+    struct stat lst;
+	/* The status fields filled in by lstat(). */
+    char *realname;
+	/* name after tilde expansion. */
+    FILE *f = NULL;
+	/* The actual file, realname, we are writing to. */
+    char *tempname = NULL;
+	/* The temp file name we write to on prepend. */
+    int backup_cflags;
+
+    assert(name != NULL);
+
+    if (*name == '\0')
+	return -1;
+
+    if (f_open != NULL)
+	f = f_open;
+
+    if (!tmp)
+	titlebar(NULL);
+
+    realname = real_dir_from_tilde(name);
+
+#ifndef DISABLE_OPERATINGDIR
+    /* If we're writing a temporary file, we're probably going outside
+     * the operating directory, so skip the operating directory test. */
+    if (!tmp && check_operating_dir(realname, FALSE)) {
+	statusbar(_("Can't write outside of %s"), operating_dir);
+	goto cleanup_and_exit;
+    }
+#endif
+
+    anyexists = (lstat(realname, &lst) != -1);
+
+    /* If the temp file exists and isn't already open, give up. */
+    if (tmp && anyexists && f_open == NULL)
+	goto cleanup_and_exit;
+
+    /* If NOFOLLOW_SYMLINKS is set, it doesn't make sense to prepend or
+     * append to a symlink.  Here we warn about the contradiction. */
+    if (ISSET(NOFOLLOW_SYMLINKS) && anyexists && S_ISLNK(lst.st_mode)) {
+	statusbar(
+		_("Cannot prepend or append to a symlink with --nofollow set"));
+	goto cleanup_and_exit;
+    }
+
+    /* Save the state of the file at the end of the symlink (if there is
+     * one). */
+    realexists = (stat(realname, &st) != -1);
+
+#ifndef NANO_TINY
+    /* if we have not stat()d this file before (say, the user just
+     * specified it interactively), stat and save the value
+     * or else we will chase null pointers when we do
+     * modtime checks, preserve file times, etc. during backup */
+    if (openfile->current_stat == NULL && !tmp && realexists)
+	stat(realname, openfile->current_stat);
+
+    /* We backup only if the backup toggle is set, the file isn't
+     * temporary, and the file already exists.  Furthermore, if we
+     * aren't appending, prepending, or writing a selection, we backup
+     * only if the file has not been modified by someone else since nano
+     * opened it. */
+    if (ISSET(BACKUP_FILE) && !tmp && realexists && ((append !=
+	OVERWRITE || openfile->mark_set) || (openfile->current_stat &&
+	openfile->current_stat->st_mtime == st.st_mtime))) {
+	int backup_fd;
+	FILE *backup_file;
+	char *backupname;
+	struct utimbuf filetime;
+	int copy_status;
+
+	/* Save the original file's access and modification times. */
+	filetime.actime = openfile->current_stat->st_atime;
+	filetime.modtime = openfile->current_stat->st_mtime;
+
+	if (f_open == NULL) {
+	    /* Open the original file to copy to the backup. */
+	    f = fopen(realname, "rb");
+
+	    if (f == NULL) {
+		statusbar(_("Error reading %s: %s"), realname,
+			strerror(errno));
+		beep();
+		/* If we can't read from the original file, go on, since
+		 * only saving the original file is better than saving
+		 * nothing. */
+		goto skip_backup;
+	    }
+	}
+
+	/* If backup_dir is set, we set backupname to
+	 * backup_dir/backupname~[.number], where backupname is the
+	 * canonicalized absolute pathname of realname with every '/'
+	 * replaced with a '!'.  This means that /home/foo/file is
+	 * backed up in backup_dir/!home!foo!file~[.number]. */
+	if (backup_dir != NULL) {
+	    char *backuptemp = get_full_path(realname);
+
+	    if (backuptemp == NULL)
+		/* If get_full_path() failed, we don't have a
+		 * canonicalized absolute pathname, so just use the
+		 * filename portion of the pathname.  We use tail() so
+		 * that e.g. ../backupname will be backed up in
+		 * backupdir/backupname~ instead of
+		 * backupdir/../backupname~. */
+		backuptemp = mallocstrcpy(NULL, tail(realname));
+	    else {
+		size_t i = 0;
+
+		for (; backuptemp[i] != '\0'; i++) {
+		    if (backuptemp[i] == '/')
+			backuptemp[i] = '!';
+		}
+	    }
+
+	    backupname = charalloc(strlen(backup_dir) +
+		strlen(backuptemp) + 1);
+	    sprintf(backupname, "%s%s", backup_dir, backuptemp);
+	    free(backuptemp);
+	    backuptemp = get_next_filename(backupname, "~");
+	    if (*backuptemp == '\0') {
+		statusbar(_("Error writing backup file %s: %s"), backupname,
+		    _("Too many backup files?"));
+		free(backuptemp);
+		free(backupname);
+		/* If we can't write to the backup, DONT go on, since
+		   whatever caused the backup file to fail (e.g. disk
+		   full may well cause the real file write to fail, which
+		   means we could lose both the backup and the original! */
+		goto cleanup_and_exit;
+	    } else {
+		free(backupname);
+		backupname = backuptemp;
+	    }
+	} else {
+	    backupname = charalloc(strlen(realname) + 2);
+	    sprintf(backupname, "%s~", realname);
+	}
+
+	/* First, unlink any existing backups.  Next, open the backup
+	   file with O_CREAT and O_EXCL.  If it succeeds, we
+	   have a file descriptor to a new backup file. */
+	if (unlink(backupname) < 0 && errno != ENOENT && !ISSET(INSECURE_BACKUP)) {
+	    if (prompt_failed_backupwrite(backupname))
+		goto skip_backup;
+	    statusbar(_("Error writing backup file %s: %s"), backupname,
+			strerror(errno));
+	    free(backupname);
+	    goto cleanup_and_exit;
+	}
+
+	if (ISSET(INSECURE_BACKUP))
+	    backup_cflags = O_WRONLY | O_CREAT | O_APPEND;
+        else
+	    backup_cflags = O_WRONLY | O_CREAT | O_EXCL | O_APPEND;
+
+	backup_fd = open(backupname, backup_cflags,
+		S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
+	/* Now we've got a safe file stream.  If the previous open()
+	   call failed, this will return NULL. */
+	backup_file = fdopen(backup_fd, "wb");
+
+	if (backup_fd < 0 || backup_file == NULL) {
+	    statusbar(_("Error writing backup file %s: %s"), backupname,
+			strerror(errno));
+	    free(backupname);
+	    goto cleanup_and_exit;
+	}
+
+        /* We shouldn't worry about chown()ing something if we're not
+	   root, since it's likely to fail! */
+	if (geteuid() == NANO_ROOT_UID && fchown(backup_fd,
+		openfile->current_stat->st_uid, openfile->current_stat->st_gid) == -1
+		&& !ISSET(INSECURE_BACKUP)) {
+	    if (prompt_failed_backupwrite(backupname))
+		goto skip_backup;
+	    statusbar(_("Error writing backup file %s: %s"), backupname,
+		strerror(errno));
+	    free(backupname);
+	    fclose(backup_file);
+	    goto cleanup_and_exit;
+	}
+
+	if (fchmod(backup_fd, openfile->current_stat->st_mode) == -1
+		&& !ISSET(INSECURE_BACKUP)) {
+	    if (prompt_failed_backupwrite(backupname))
+		goto skip_backup;
+	    statusbar(_("Error writing backup file %s: %s"), backupname,
+		strerror(errno));
+	    free(backupname);
+	    fclose(backup_file);
+	    /* If we can't write to the backup, DONT go on, since
+	       whatever caused the backup file to fail (e.g. disk
+	       full may well cause the real file write to fail, which
+	       means we could lose both the backup and the original! */
+	    goto cleanup_and_exit;
+	}
+
+#ifdef DEBUG
+	fprintf(stderr, "Backing up %s to %s\n", realname, backupname);
+#endif
+
+	/* Copy the file. */
+	copy_status = copy_file(f, backup_file);
+
+	if (copy_status != 0) {
+	    statusbar(_("Error reading %s: %s"), realname,
+			strerror(errno));
+	    beep();
+	    goto cleanup_and_exit;
+	}
+
+	/* And set its metadata. */
+	if (utime(backupname, &filetime) == -1 && !ISSET(INSECURE_BACKUP)) {
+	    if (prompt_failed_backupwrite(backupname))
+		goto skip_backup;
+	    statusbar(_("Error writing backup file %s: %s"), backupname,
+			strerror(errno));
+	    /* If we can't write to the backup, DONT go on, since
+	       whatever caused the backup file to fail (e.g. disk
+	       full may well cause the real file write to fail, which
+	       means we could lose both the backup and the original! */
+	    goto cleanup_and_exit;
+	}
+
+	free(backupname);
+    }
+
+    skip_backup:
+#endif /* !NANO_TINY */
+
+    /* If NOFOLLOW_SYMLINKS is set and the file is a link, we aren't
+     * doing prepend or append.  So we delete the link first, and just
+     * overwrite. */
+    if (ISSET(NOFOLLOW_SYMLINKS) && anyexists && S_ISLNK(lst.st_mode) &&
+	unlink(realname) == -1) {
+	statusbar(_("Error writing %s: %s"), realname, strerror(errno));
+	goto cleanup_and_exit;
+    }
+
+    if (f_open == NULL) {
+	original_umask = umask(0);
+
+	/* If we create a temp file, we don't let anyone else access it.
+	 * We create a temp file if tmp is TRUE. */
+	if (tmp)
+	    umask(S_IRWXG | S_IRWXO);
+	else
+	    umask(original_umask);
+    }
+
+    /* If we're prepending, copy the file to a temp file. */
+    if (append == PREPEND) {
+	int fd_source;
+	FILE *f_source = NULL;
+
+	if (f == NULL) {
+	    f = fopen(realname, "rb");
+
+	    if (f == NULL) {
+		statusbar(_("Error reading %s: %s"), realname,
+			strerror(errno));
+		beep();
+		goto cleanup_and_exit;
+	    }
+	}
+
+	tempname = safe_tempfile(&f);
+
+	if (tempname == NULL) {
+	    statusbar(_("Error writing temp file: %s"),
+		strerror(errno));
+	    goto cleanup_and_exit;
+	}
+
+	if (f_open == NULL) {
+	    fd_source = open(realname, O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR);
+
+	    if (fd_source != -1) {
+		f_source = fdopen(fd_source, "rb");
+		if (f_source == NULL) {
+		    statusbar(_("Error reading %s: %s"), realname,
+			strerror(errno));
+		    beep();
+		    close(fd_source);
+		    fclose(f);
+		    unlink(tempname);
+		    goto cleanup_and_exit;
+		}
+	    }
+	}
+
+	if (copy_file(f_source, f) != 0) {
+	    statusbar(_("Error writing %s: %s"), tempname,
+		strerror(errno));
+	    unlink(tempname);
+	    goto cleanup_and_exit;
+	}
+    }
+
+    if (f_open == NULL) {
+	/* Now open the file in place.  Use O_EXCL if tmp is TRUE.  This
+	 * is copied from joe, because wiggy says so *shrug*. */
+	fd = open(realname, O_WRONLY | O_CREAT | ((append == APPEND) ?
+		O_APPEND : (tmp ? O_EXCL : O_TRUNC)), S_IRUSR |
+		S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
+
+	/* Set the umask back to the user's original value. */
+	umask(original_umask);
+
+	/* If we couldn't open the file, give up. */
+	if (fd == -1) {
+	    statusbar(_("Error writing %s: %s"), realname,
+		strerror(errno));
+
+	    /* tempname has been set only if we're prepending. */
+	    if (tempname != NULL)
+		unlink(tempname);
+	    goto cleanup_and_exit;
+	}
+
+	f = fdopen(fd, (append == APPEND) ? "ab" : "wb");
+
+	if (f == NULL) {
+	    statusbar(_("Error writing %s: %s"), realname,
+		strerror(errno));
+	    close(fd);
+	    goto cleanup_and_exit;
+	}
+    }
+
+    /* There might not be a magicline.  There won't be when writing out
+     * a selection. */
+    assert(openfile->fileage != NULL && openfile->filebot != NULL);
+
+    while (fileptr != NULL) {
+	size_t data_len = strlen(fileptr->data), size;
+
+	/* Convert newlines to nulls, just before we write to disk. */
+	sunder(fileptr->data);
+
+	size = fwrite(fileptr->data, sizeof(char), data_len, f);
+
+	/* Convert nulls to newlines.  data_len is the string's real
+	 * length. */
+	unsunder(fileptr->data, data_len);
+
+	if (size < data_len) {
+	    statusbar(_("Error writing %s: %s"), realname,
+		strerror(errno));
+	    fclose(f);
+	    goto cleanup_and_exit;
+	}
+
+	/* If we're on the last line of the file, don't write a newline
+	 * character after it.  If the last line of the file is blank,
+	 * this means that zero bytes are written, in which case we
+	 * don't count the last line in the total lines written. */
+	if (fileptr == openfile->filebot) {
+	    if (fileptr->data[0] == '\0')
+		lineswritten--;
+	} else {
+#ifndef NANO_TINY
+	    if (openfile->fmt == DOS_FILE || openfile->fmt ==
+		MAC_FILE) {
+		if (putc('\r', f) == EOF) {
+		    statusbar(_("Error writing %s: %s"), realname,
+			strerror(errno));
+		    fclose(f);
+		    goto cleanup_and_exit;
+		}
+	    }
+
+	    if (openfile->fmt != MAC_FILE) {
+#endif
+		if (putc('\n', f) == EOF) {
+		    statusbar(_("Error writing %s: %s"), realname,
+			strerror(errno));
+		    fclose(f);
+		    goto cleanup_and_exit;
+		}
+#ifndef NANO_TINY
+	    }
+#endif
+	}
+
+	fileptr = fileptr->next;
+	lineswritten++;
+    }
+
+    /* If we're prepending, open the temp file, and append it to f. */
+    if (append == PREPEND) {
+	int fd_source;
+	FILE *f_source = NULL;
+
+	fd_source = open(tempname, O_RDONLY | O_CREAT, S_IRUSR | S_IWUSR);
+
+	if (fd_source != -1) {
+	    f_source = fdopen(fd_source, "rb");
+	    if (f_source == NULL)
+		close(fd_source);
+	}
+
+	if (f_source == NULL) {
+	    statusbar(_("Error reading %s: %s"), tempname,
+		strerror(errno));
+	    beep();
+	    fclose(f);
+	    goto cleanup_and_exit;
+	}
+
+	if (copy_file(f_source, f) == -1 || unlink(tempname) == -1) {
+	    statusbar(_("Error writing %s: %s"), realname,
+		strerror(errno));
+	    goto cleanup_and_exit;
+	}
+    } else if (fclose(f) != 0) {
+	    statusbar(_("Error writing %s: %s"), realname,
+		strerror(errno));
+	    goto cleanup_and_exit;
+    }
+
+    if (!tmp && append == OVERWRITE) {
+	if (!nonamechange) {
+	    openfile->filename = mallocstrcpy(openfile->filename,
+		realname);
+#ifdef ENABLE_COLOR
+	    /* We might have changed the filename, so update the colors
+	     * to account for it, and then make sure we're using
+	     * them. */
+	    color_update();
+	    color_init();
+
+	    /* If color syntaxes are available and turned on, we need to
+	     * call edit_refresh(). */
+	    if (openfile->colorstrings != NULL &&
+		!ISSET(NO_COLOR_SYNTAX))
+		edit_refresh();
+#endif
+	}
+
+#ifndef NANO_TINY
+	/* Update current_stat to reference the file as it is now. */
+	if (openfile->current_stat == NULL)
+	    openfile->current_stat =
+		(struct stat *)nmalloc(sizeof(struct stat));
+	stat(realname, openfile->current_stat);
+#endif
+
+	statusbar(P_("Wrote %lu line", "Wrote %lu lines",
+		(unsigned long)lineswritten),
+		(unsigned long)lineswritten);
+	openfile->modified = FALSE;
+	titlebar(NULL);
+    }
+
+    retval = TRUE;
+
+  cleanup_and_exit:
+    free(realname);
+    if (tempname != NULL)
+	free(tempname);
+
+    return retval;
+}
+
+#ifndef NANO_TINY
+/* Write a marked selection from a file out to disk.  Return TRUE on
+ * success or FALSE on error. */
+bool write_marked_file(const char *name, FILE *f_open, bool tmp,
+	append_type append)
+{
+    bool retval;
+    bool old_modified = openfile->modified;
+	/* write_file() unsets the modified flag. */
+    bool added_magicline = FALSE;
+	/* Whether we added a magicline after filebot. */
+    filestruct *top, *bot;
+    size_t top_x, bot_x;
+
+    assert(openfile->mark_set);
+
+    /* Partition the filestruct so that it contains only the marked
+     * text. */
+    mark_order((const filestruct **)&top, &top_x,
+	(const filestruct **)&bot, &bot_x, NULL);
+    filepart = partition_filestruct(top, top_x, bot, bot_x);
+
+    /* Handle the magicline if the NO_NEWLINES flag isn't set.  If the
+     * line at filebot is blank, treat it as the magicline and hence the
+     * end of the file.  Otherwise, add a magicline and treat it as the
+     * end of the file. */
+    if (!ISSET(NO_NEWLINES) &&
+	(added_magicline = (openfile->filebot->data[0] != '\0')))
+	new_magicline();
+
+    retval = write_file(name, f_open, tmp, append, TRUE);
+
+    /* If the NO_NEWLINES flag isn't set, and we added a magicline,
+     * remove it now. */
+    if (!ISSET(NO_NEWLINES) && added_magicline)
+	remove_magicline();
+
+    /* Unpartition the filestruct so that it contains all the text
+     * again. */
+    unpartition_filestruct(&filepart);
+
+    if (old_modified)
+	set_modified();
+
+    return retval;
+}
+#endif /* !NANO_TINY */
+
+/* Write the current file to disk.  If the mark is on, write the current
+ * marked selection to disk.  If exiting is TRUE, write the file to disk
+ * regardless of whether the mark is on, and without prompting if the
+ * TEMP_FILE flag is set.  Return TRUE on success or FALSE on error. */
+bool do_writeout(bool exiting)
+{
+    int i;
+    append_type append = OVERWRITE;
+    char *ans;
+	/* The last answer the user typed at the statusbar prompt. */
+#ifdef NANO_EXTRA
+    static bool did_credits = FALSE;
+#endif
+    bool retval = FALSE, meta_key = FALSE, func_key = FALSE;
+    const sc *s;
+
+    currmenu = MWRITEFILE;
+
+    if (exiting && openfile->filename[0] != '\0' && ISSET(TEMP_FILE)) {
+	retval = write_file(openfile->filename, NULL, FALSE, OVERWRITE,
+		FALSE);
+
+	/* Write succeeded. */
+	if (retval)
+	    return retval;
+    }
+
+    ans = mallocstrcpy(NULL,
+#ifndef NANO_TINY
+	(!exiting && openfile->mark_set) ? "" :
+#endif
+	openfile->filename);
+
+    while (TRUE) {
+	const char *msg;
+#ifndef NANO_TINY
+	const char *formatstr, *backupstr;
+
+	formatstr = (openfile->fmt == DOS_FILE) ?
+		_(" [DOS Format]") : (openfile->fmt == MAC_FILE) ?
+		_(" [Mac Format]") : "";
+
+	backupstr = ISSET(BACKUP_FILE) ? _(" [Backup]") : "";
+
+	/* If we're using restricted mode, don't display the "Write
+	 * Selection to File" prompt.  This function is disabled, since
+	 * it allows reading from or writing to files not specified on
+	 * the command line. */
+	if (!ISSET(RESTRICTED) && !exiting && openfile->mark_set)
+	    msg = (append == PREPEND) ?
+		_("Prepend Selection to File") : (append == APPEND) ?
+		_("Append Selection to File") :
+		_("Write Selection to File");
+	else
+#endif /* !NANO_TINY */
+	    msg = (append == PREPEND) ? _("File Name to Prepend to") :
+		(append == APPEND) ? _("File Name to Append to") :
+		_("File Name to Write");
+
+	/* If we're using restricted mode, the filename isn't blank,
+	 * and we're at the "Write File" prompt, disable tab
+	 * completion. */
+	i = do_prompt(!ISSET(RESTRICTED) ||
+		openfile->filename[0] == '\0',
+#ifndef DISABLE_TABCOMP
+		TRUE,
+#endif
+		MWRITEFILE, ans,
+		&meta_key, &func_key,
+#ifndef NANO_TINY
+		NULL,
+#endif
+		edit_refresh, "%s%s%s", msg,
+#ifndef NANO_TINY
+		formatstr, backupstr
+#else
+		"", ""
+#endif
+		);
+
+	/* If the filename or command begins with a newline (i.e. an
+	 * encoded null), treat it as though it's blank. */
+	if (i < 0 || *answer == '\n') {
+	    statusbar(_("Cancelled"));
+	    retval = FALSE;
+	    break;
+	} else {
+	    ans = mallocstrcpy(ans, answer);
+            s = get_shortcut(currmenu, &i, &meta_key, &func_key);
+
+#ifndef DISABLE_BROWSER
+	    if (s && s->scfunc == to_files_void) {
+		char *tmp = do_browse_from(answer);
+
+		if (tmp == NULL)
+		    continue;
+
+		/* We have a file now.  Indicate this. */
+		free(answer);
+		answer = tmp;
+	    } else
+#endif /* !DISABLE_BROWSER */
+#ifndef NANO_TINY
+	    if (s && s->scfunc == dos_format_void) {
+		openfile->fmt = (openfile->fmt == DOS_FILE) ? NIX_FILE :
+			DOS_FILE;
+		continue;
+	    } else if (s && s->scfunc == mac_format_void) {
+		openfile->fmt = (openfile->fmt == MAC_FILE) ? NIX_FILE :
+			MAC_FILE;
+		continue;
+	    } else if (s && s->scfunc == backup_file_void) {
+		TOGGLE(BACKUP_FILE);
+		continue;
+	    } else
+#endif /* !NANO_TINY */
+	    if (s && s->scfunc == prepend_void) {
+		append = (append == PREPEND) ? OVERWRITE : PREPEND;
+		continue;
+	    } else if (s && s->scfunc == append_void) {
+		append = (append == APPEND) ? OVERWRITE : APPEND;
+		continue;
+	    } else if (s && s->scfunc == do_help_void) {
+		continue;
+	    }
+
+#ifdef DEBUG
+	    fprintf(stderr, "filename is %s\n", answer);
+#endif
+
+#ifdef NANO_EXTRA
+	    /* If the current file has been modified, we've pressed
+	     * Ctrl-X at the edit window to exit, we've pressed "y" at
+	     * the "Save modified buffer" prompt to save, we've entered
+	     * "zzy" as the filename to save under (hence "xyzzy"), and
+	     * this is the first time we've done this, show an Easter
+	     * egg.  Display the credits. */
+	    if (!did_credits && exiting && !ISSET(TEMP_FILE) &&
+		strcasecmp(answer, "zzy") == 0) {
+		do_credits();
+		did_credits = TRUE;
+		retval = FALSE;
+		break;
+	    }
+#endif
+
+	    if (append == OVERWRITE) {
+		size_t answer_len = strlen(answer);
+		bool name_exists, do_warning;
+		char *full_answer, *full_filename;
+		struct stat st;
+
+		/* Convert newlines to nulls, just before we get the
+		 * full path. */
+		sunder(answer);
+
+		full_answer = get_full_path(answer);
+		full_filename = get_full_path(openfile->filename);
+		name_exists = (stat((full_answer == NULL) ? answer :
+			full_answer, &st) != -1);
+		if (openfile->filename[0] == '\0')
+		    do_warning = name_exists;
+		else
+		    do_warning = (strcmp((full_answer == NULL) ?
+			answer : full_answer, (full_filename == NULL) ?
+			openfile->filename : full_filename) != 0);
+
+		/* Convert nulls to newlines.  answer_len is the
+		 * string's real length. */
+		unsunder(answer, answer_len);
+
+		if (full_filename != NULL)
+		    free(full_filename);
+		if (full_answer != NULL)
+		    free(full_answer);
+
+		if (do_warning) {
+		    /* If we're using restricted mode, we aren't allowed
+		     * to overwrite an existing file with the current
+		     * file.  We also aren't allowed to change the name
+		     * of the current file if it has one, because that
+		     * would allow reading from or writing to files not
+		     * specified on the command line. */
+		    if (ISSET(RESTRICTED))
+			continue;
+
+		    if (name_exists) {
+			i = do_yesno_prompt(FALSE,
+				_("File exists, OVERWRITE ? "));
+			if (i == 0 || i == -1)
+			    continue;
+		    } else
+#ifndef NANO_TINY
+		    if (exiting || !openfile->mark_set)
+#endif
+		    {
+			i = do_yesno_prompt(FALSE,
+				_("Save file under DIFFERENT NAME ? "));
+			if (i == 0 || i == -1)
+			    continue;
+		    }
+		}
+#ifndef NANO_TINY
+		/* Complain if the file exists, the name hasn't changed, and the
+		    stat information we had before does not match what we have now */
+		else if (name_exists && openfile->current_stat && (openfile->current_stat->st_mtime < st.st_mtime ||
+                    openfile->current_stat->st_dev != st.st_dev || openfile->current_stat->st_ino != st.st_ino)) {
+		    i = do_yesno_prompt(FALSE,
+			_("File was modified since you opened it, continue saving ? "));
+		    if (i == 0 || i == -1)
+			continue;
+		}
+#endif
+
+	    }
+
+	    /* Convert newlines to nulls, just before we save the
+	     * file. */
+	    sunder(answer);
+	    align(&answer);
+
+	    /* Here's where we allow the selected text to be written to
+	     * a separate file.  If we're using restricted mode, this
+	     * function is disabled, since it allows reading from or
+	     * writing to files not specified on the command line. */
+	    retval =
+#ifndef NANO_TINY
+		(!ISSET(RESTRICTED) && !exiting && openfile->mark_set) ?
+		write_marked_file(answer, NULL, FALSE, append) :
+#endif
+		write_file(answer, NULL, FALSE, append, FALSE);
+
+	    break;
+	}
+    }
+
+    free(ans);
+
+    return retval;
+}
+
+/* Write the current file to disk.  If the mark is on, write the current
+ * marked selection to disk. */
+void do_writeout_void(void)
+{
+    do_writeout(FALSE);
+    display_main_list();
+}
+
+/* Return a malloc()ed string containing the actual directory, used to
+ * convert ~user/ and ~/ notation. */
+char *real_dir_from_tilde(const char *buf)
+{
+    char *retval;
+
+    assert(buf != NULL);
+
+    if (*buf == '~') {
+	size_t i = 1;
+	char *tilde_dir;
+
+	/* Figure out how much of the string we need to compare. */
+	for (; buf[i] != '/' && buf[i] != '\0'; i++)
+	    ;
+
+	/* Get the home directory. */
+	if (i == 1) {
+	    get_homedir();
+	    tilde_dir = mallocstrcpy(NULL, homedir);
+	} else {
+	    const struct passwd *userdata;
+
+	    tilde_dir = mallocstrncpy(NULL, buf, i + 1);
+	    tilde_dir[i] = '\0';
+
+	    do {
+		userdata = getpwent();
+	    } while (userdata != NULL && strcmp(userdata->pw_name,
+		tilde_dir + 1) != 0);
+	    endpwent();
+	    if (userdata != NULL)
+		tilde_dir = mallocstrcpy(tilde_dir, userdata->pw_dir);
+	}
+
+	retval = charalloc(strlen(tilde_dir) + strlen(buf + i) + 1);
+	sprintf(retval, "%s%s", tilde_dir, buf + i);
+
+	free(tilde_dir);
+    } else
+	retval = mallocstrcpy(NULL, buf);
+
+    return retval;
+}
+
+#if !defined(DISABLE_TABCOMP) || !defined(DISABLE_BROWSER)
+/* Our sort routine for file listings.  Sort alphabetically and
+ * case-insensitively, and sort directories before filenames. */
+int diralphasort(const void *va, const void *vb)
+{
+    struct stat fileinfo;
+    const char *a = *(const char *const *)va;
+    const char *b = *(const char *const *)vb;
+    bool aisdir = stat(a, &fileinfo) != -1 && S_ISDIR(fileinfo.st_mode);
+    bool bisdir = stat(b, &fileinfo) != -1 && S_ISDIR(fileinfo.st_mode);
+
+    if (aisdir && !bisdir)
+	return -1;
+    if (!aisdir && bisdir)
+	return 1;
+
+    /* Standard function brain damage: We should be sorting
+     * alphabetically and case-insensitively according to the current
+     * locale, but there's no standard strcasecoll() function, so we
+     * have to use multibyte strcasecmp() instead, */
+    return mbstrcasecmp(a, b);
+}
+
+/* Free the memory allocated for array, which should contain len
+ * elements. */
+void free_chararray(char **array, size_t len)
+{
+    assert(array != NULL);
+
+    for (; len > 0; len--)
+	free(array[len - 1]);
+    free(array);
+}
+#endif
+
+#ifndef DISABLE_TABCOMP
+/* Is the given path a directory? */
+bool is_dir(const char *buf)
+{
+    char *dirptr;
+    struct stat fileinfo;
+    bool retval;
+
+    assert(buf != NULL);
+
+    dirptr = real_dir_from_tilde(buf);
+
+    retval = (stat(dirptr, &fileinfo) != -1 &&
+	S_ISDIR(fileinfo.st_mode));
+
+    free(dirptr);
+
+    return retval;
+}
+
+/* These functions, username_tab_completion(), cwd_tab_completion()
+ * (originally exe_n_cwd_tab_completion()), and input_tab(), were
+ * adapted from busybox 0.46 (cmdedit.c).  Here is the notice from that
+ * file, with the copyright years updated:
+ *
+ * Termios command line History and Editting, originally
+ * intended for NetBSD sh (ash)
+ * Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
+ *      Main code:            Adam Rogoyski <rogoyski@cs.utexas.edu>
+ *      Etc:                  Dave Cinege <dcinege@psychosis.com>
+ *  Majorly adjusted/re-written for busybox:
+ *                            Erik Andersen <andersee@debian.org>
+ *
+ * You may use this code as you wish, so long as the original author(s)
+ * are attributed in any redistributions of the source code.
+ * This code is 'as is' with no warranty.
+ * This code may safely be consumed by a BSD or GPL license. */
+
+/* We consider the first buf_len characters of buf for ~username tab
+ * completion. */
+char **username_tab_completion(const char *buf, size_t *num_matches,
+	size_t buf_len)
+{
+    char **matches = NULL;
+    const struct passwd *userdata;
+
+    assert(buf != NULL && num_matches != NULL && buf_len > 0);
+
+    *num_matches = 0;
+
+    while ((userdata = getpwent()) != NULL) {
+	if (strncmp(userdata->pw_name, buf + 1, buf_len - 1) == 0) {
+	    /* Cool, found a match.  Add it to the list.  This makes a
+	     * lot more sense to me (Chris) this way... */
+
+#ifndef DISABLE_OPERATINGDIR
+	    /* ...unless the match exists outside the operating
+	     * directory, in which case just go to the next match. */
+	    if (check_operating_dir(userdata->pw_dir, TRUE))
+		continue;
+#endif
+
+	    matches = (char **)nrealloc(matches, (*num_matches + 1) *
+		sizeof(char *));
+	    matches[*num_matches] =
+		charalloc(strlen(userdata->pw_name) + 2);
+	    sprintf(matches[*num_matches], "~%s", userdata->pw_name);
+	    ++(*num_matches);
+	}
+    }
+    endpwent();
+
+    return matches;
+}
+
+/* We consider the first buf_len characters of buf for filename tab
+ * completion. */
+char **cwd_tab_completion(const char *buf, bool allow_files, size_t
+	*num_matches, size_t buf_len)
+{
+    char *dirname = mallocstrcpy(NULL, buf), *filename;
+#ifndef DISABLE_OPERATINGDIR
+    size_t dirnamelen;
+#endif
+    size_t filenamelen;
+    char **matches = NULL;
+    DIR *dir;
+    const struct dirent *nextdir;
+
+    assert(dirname != NULL && num_matches != NULL);
+
+    *num_matches = 0;
+    null_at(&dirname, buf_len);
+
+    /* Okie, if there's a / in the buffer, strip out the directory
+     * part. */
+    filename = strrchr(dirname, '/');
+    if (filename != NULL) {
+	char *tmpdirname = filename + 1;
+
+	filename = mallocstrcpy(NULL, tmpdirname);
+	*tmpdirname = '\0';
+	tmpdirname = dirname;
+	dirname = real_dir_from_tilde(dirname);
+	free(tmpdirname);
+    } else {
+	filename = dirname;
+	dirname = mallocstrcpy(NULL, "./");
+    }
+
+    assert(dirname[strlen(dirname) - 1] == '/');
+
+    dir = opendir(dirname);
+
+    if (dir == NULL) {
+	/* Don't print an error, just shut up and return. */
+	beep();
+	free(filename);
+	free(dirname);
+	return NULL;
+    }
+
+#ifndef DISABLE_OPERATINGDIR
+    dirnamelen = strlen(dirname);
+#endif
+    filenamelen = strlen(filename);
+
+    while ((nextdir = readdir(dir)) != NULL) {
+	bool skip_match = FALSE;
+
+#ifdef DEBUG
+	fprintf(stderr, "Comparing \'%s\'\n", nextdir->d_name);
+#endif
+	/* See if this matches. */
+	if (strncmp(nextdir->d_name, filename, filenamelen) == 0 &&
+		(*filename == '.' || (strcmp(nextdir->d_name, ".") !=
+		0 && strcmp(nextdir->d_name, "..") != 0))) {
+	    /* Cool, found a match.  Add it to the list.  This makes a
+	     * lot more sense to me (Chris) this way... */
+
+	    char *tmp = charalloc(strlen(dirname) +
+		strlen(nextdir->d_name) + 1);
+	    sprintf(tmp, "%s%s", dirname, nextdir->d_name);
+
+#ifndef DISABLE_OPERATINGDIR
+	    /* ...unless the match exists outside the operating
+	     * directory, in which case just go to the next match. */
+	    if (check_operating_dir(tmp, TRUE))
+		skip_match = TRUE;
+#endif
+
+	    /* ...or unless the match isn't a directory and allow_files
+	     * isn't set, in which case just go to the next match. */
+	    if (!allow_files && !is_dir(tmp))
+		skip_match = TRUE;
+
+	    free(tmp);
+
+	    if (skip_match)
+		continue;
+
+	    matches = (char **)nrealloc(matches, (*num_matches + 1) *
+		sizeof(char *));
+	    matches[*num_matches] = mallocstrcpy(NULL, nextdir->d_name);
+	    ++(*num_matches);
+	}
+    }
+
+    closedir(dir);
+    free(dirname);
+    free(filename);
+
+    return matches;
+}
+
+/* Do tab completion.  place refers to how much the statusbar cursor
+ * position should be advanced.  refresh_func is the function we will
+ * call to refresh the edit window. */
+char *input_tab(char *buf, bool allow_files, size_t *place, bool
+	*lastwastab, void (*refresh_func)(void), bool *list)
+{
+    size_t num_matches = 0, buf_len;
+    char **matches = NULL;
+
+    assert(buf != NULL && place != NULL && *place <= strlen(buf) && lastwastab != NULL && refresh_func != NULL && list != NULL);
+
+    *list = FALSE;
+
+    /* If the word starts with `~' and there is no slash in the word,
+     * then try completing this word as a username. */
+    if (*place > 0 && *buf == '~') {
+	const char *bob = strchr(buf, '/');
+
+	if (bob == NULL || bob >= buf + *place)
+	    matches = username_tab_completion(buf, &num_matches,
+		*place);
+    }
+
+    /* Match against files relative to the current working directory. */
+    if (matches == NULL)
+	matches = cwd_tab_completion(buf, allow_files, &num_matches,
+		*place);
+
+    buf_len = strlen(buf);
+
+    if (num_matches == 0 || *place != buf_len)
+	beep();
+    else {
+	size_t match, common_len = 0;
+	char *mzero;
+	const char *lastslash = revstrstr(buf, "/", buf + *place);
+	size_t lastslash_len = (lastslash == NULL) ? 0 :
+		lastslash - buf + 1;
+	char *match1_mb = charalloc(mb_cur_max() + 1);
+	char *match2_mb = charalloc(mb_cur_max() + 1);
+	int match1_mb_len, match2_mb_len;
+
+	while (TRUE) {
+	    for (match = 1; match < num_matches; match++) {
+		/* Get the number of single-byte characters that all the
+		 * matches have in common. */
+		match1_mb_len = parse_mbchar(matches[0] + common_len,
+			match1_mb, NULL);
+		match2_mb_len = parse_mbchar(matches[match] +
+			common_len, match2_mb, NULL);
+		match1_mb[match1_mb_len] = '\0';
+		match2_mb[match2_mb_len] = '\0';
+		if (strcmp(match1_mb, match2_mb) != 0)
+		    break;
+	    }
+
+	    if (match < num_matches || matches[0][common_len] == '\0')
+		break;
+
+	    common_len += parse_mbchar(buf + common_len, NULL, NULL);
+	}
+
+	free(match1_mb);
+	free(match2_mb);
+
+	mzero = charalloc(lastslash_len + common_len + 1);
+
+	strncpy(mzero, buf, lastslash_len);
+	strncpy(mzero + lastslash_len, matches[0], common_len);
+
+	common_len += lastslash_len;
+	mzero[common_len] = '\0';
+
+	assert(common_len >= *place);
+
+	if (num_matches == 1 && is_dir(mzero)) {
+	    mzero[common_len++] = '/';
+
+	    assert(common_len > *place);
+	}
+
+	if (num_matches > 1 && (common_len != *place || !*lastwastab))
+	    beep();
+
+	/* If there is more of a match to display on the statusbar, show
+	 * it.  We reset lastwastab to FALSE: it requires pressing Tab
+	 * twice in succession with no statusbar changes to see a match
+	 * list. */
+	if (common_len != *place) {
+	    *lastwastab = FALSE;
+	    buf = charealloc(buf, common_len + buf_len - *place + 1);
+	    charmove(buf + common_len, buf + *place, buf_len -
+		*place + 1);
+	    strncpy(buf, mzero, common_len);
+	    *place = common_len;
+	} else if (!*lastwastab || num_matches < 2)
+	    *lastwastab = TRUE;
+	else {
+	    int longest_name = 0, ncols, editline = 0;
+
+	    /* Now we show a list of the available choices. */
+	    assert(num_matches > 1);
+
+	    /* Sort the list. */
+	    qsort(matches, num_matches, sizeof(char *), diralphasort);
+
+	    for (match = 0; match < num_matches; match++) {
+		common_len = strnlenpt(matches[match], COLS - 1);
+
+		if (common_len > COLS - 1) {
+		    longest_name = COLS - 1;
+		    break;
+		}
+
+		if (common_len > longest_name)
+		    longest_name = common_len;
+	    }
+
+	    assert(longest_name <= COLS - 1);
+
+	    /* Each column will be (longest_name + 2) columns wide, i.e.
+	     * two spaces between columns, except that there will be
+	     * only one space after the last column. */
+	    ncols = (COLS + 1) / (longest_name + 2);
+
+	    /* Blank the edit window, and print the matches out
+	     * there. */
+	    blank_edit();
+	    wmove(edit, 0, 0);
+
+	    /* Disable el cursor. */
+	    curs_set(0);
+
+	    for (match = 0; match < num_matches; match++) {
+		char *disp;
+
+		wmove(edit, editline, (longest_name + 2) *
+			(match % ncols));
+
+		if (match % ncols == 0 &&
+			editline == editwinrows - 1 &&
+			num_matches - match > ncols) {
+		    waddstr(edit, _("(more)"));
+		    break;
+		}
+
+		disp = display_string(matches[match], 0, longest_name,
+			FALSE);
+		waddstr(edit, disp);
+		free(disp);
+
+		if ((match + 1) % ncols == 0)
+		    editline++;
+	    }
+
+	    wnoutrefresh(edit);
+	    *list = TRUE;
+	}
+
+	free(mzero);
+    }
+
+    free_chararray(matches, num_matches);
+
+    /* Only refresh the edit window if we don't have a list of filename
+     * matches on it. */
+    if (!*list)
+	refresh_func();
+
+    /* Enable el cursor. */
+    curs_set(1);
+
+    return buf;
+}
+#endif /* !DISABLE_TABCOMP */
+
+/* Only print the last part of a path.  Isn't there a shell command for
+ * this? */
+const char *tail(const char *foo)
+{
+    const char *tmp = strrchr(foo, '/');
+
+    if (tmp == NULL)
+	tmp = foo;
+    else
+	tmp++;
+
+    return tmp;
+}
+
+#if !defined(NANO_TINY) && defined(ENABLE_NANORC)
+/* Return the constructed dorfile path, or NULL if we can't find the home
+ * directory.  The string is dynamically allocated, and should be
+ * freed. */
+char *construct_filename(const char *str)
+{
+    char *newstr = NULL;
+
+    if (homedir != NULL) {
+	size_t homelen = strlen(homedir);
+
+	newstr = charalloc(homelen + strlen(str) + 1);
+	strcpy(newstr, homedir);
+	strcpy(newstr + homelen, str);
+    }
+
+    return newstr;
+
+}
+
+char *histfilename(void)
+{
+    return construct_filename("/.nano/search_history");
+}
+
+/* Construct the legacy history filename
+ * (Deprecate in 2.5, delete later
+ */
+char *legacyhistfilename(void)
+{
+    return construct_filename("/.nano_history");
+}
+
+char *poshistfilename(void)
+{
+    return construct_filename("/.nano/filepos_history");
+}
+
+
+
+void history_error(const char *msg, ...)
+{
+   va_list ap;
+
+    va_start(ap, msg);
+    vfprintf(stderr, _(msg), ap);
+    va_end(ap);
+
+    fprintf(stderr, _("\nPress Enter to continue\n"));
+    while (getchar() != '\n')
+	;
+
+}
+
+/* Now that we have more than one history file, let's just rely
+   on a .nano dir for this stuff.  Return 1 if the dir exists
+   or was successfully created, and return 0 otherwise.
+ */
+int check_dotnano(void)
+{
+    struct stat dirstat;
+    char *nanodir = construct_filename("/.nano");
+
+    if (stat(nanodir, &dirstat) == -1) {
+	if (mkdir(nanodir, S_IRWXU | S_IRWXG | S_IRWXO) == -1) {
+	    history_error(N_("Unable to create directory %s: %s\nIt is required for saving/loading search history or cursor position\n"),
+		nanodir, strerror(errno));
+	    return 0;
+	}
+    } else if (!S_ISDIR(dirstat.st_mode)) {
+	history_error(N_("Path %s is not a directory and needs to be.\nNano will be unable to load or save search or cursor position history\n"));
+	return 0;
+    }
+    return 1;
+}
+
+/* Load histories from ~/.nano_history. */
+void load_history(void)
+{
+    char *nanohist = histfilename();
+    char *legacyhist = legacyhistfilename();
+    struct stat hstat;
+
+
+    if (stat(legacyhist, &hstat) != -1 && stat(nanohist, &hstat) == -1) {
+	if (rename(legacyhist, nanohist)  == -1)
+	    history_error(N_("Detected a legacy nano history file (%s) which I tried to move\nto the preferred location (%s) but encountered an error: %s"),
+		legacyhist, nanohist, strerror(errno));
+	else
+	    history_error(N_("Detected a legacy nano history file (%s) which I moved\nto the preferred location (%s)\n(see the nano FAQ about this change)"),
+		legacyhist, nanohist);
+    }
+
+
+
+    /* Assume do_rcfile() has reported a missing home directory. */
+    if (nanohist != NULL) {
+	FILE *hist = fopen(nanohist, "rb");
+
+	if (hist == NULL) {
+	    if (errno != ENOENT) {
+		/* Don't save history when we quit. */
+		UNSET(HISTORYLOG);
+		history_error(N_("Error reading %s: %s"), nanohist,
+			strerror(errno));
+	    }
+	} else {
+	    /* Load a history list (first the search history, then the
+	     * replace history) from the oldest entry to the newest.
+	     * Assume the last history entry is a blank line. */
+	    filestruct **history = &search_history;
+	    char *line = NULL;
+	    size_t buf_len = 0;
+	    ssize_t read;
+
+	    while ((read = getline(&line, &buf_len, hist)) >= 0) {
+		if (read > 0 && line[read - 1] == '\n') {
+		    read--;
+		    line[read] = '\0';
+		}
+		if (read > 0) {
+		    unsunder(line, read);
+		    update_history(history, line);
+		} else
+		    history = &replace_history;
+	    }
+
+	    fclose(hist);
+	    free(line);
+	    if (search_history->prev != NULL)
+		last_search = mallocstrcpy(NULL, search_history->prev->data);
+	}
+	free(nanohist);
+	free(legacyhist);
+    }
+}
+
+/* Write the lines of a history list, starting with the line at h, to
+ * the open file at hist.  Return TRUE if the write succeeded, and FALSE
+ * otherwise. */
+bool writehist(FILE *hist, filestruct *h)
+{
+    filestruct *p;
+
+    /* Write a history list from the oldest entry to the newest.  Assume
+     * the last history entry is a blank line. */
+    for (p = h; p != NULL; p = p->next) {
+	size_t p_len = strlen(p->data);
+
+	sunder(p->data);
+
+	if (fwrite(p->data, sizeof(char), p_len, hist) < p_len ||
+		putc('\n', hist) == EOF)
+	    return FALSE;
+    }
+
+    return TRUE;
+}
+
+/* Save histories to ~/.nano/search_history. */
+void save_history(void)
+{
+    char *nanohist;
+
+    /* Don't save unchanged or empty histories. */
+    if (!history_has_changed() || (searchbot->lineno == 1 &&
+	replacebot->lineno == 1))
+	return;
+
+    nanohist = histfilename();
+
+    if (nanohist != NULL) {
+	FILE *hist = fopen(nanohist, "wb");
+
+	if (hist == NULL)
+	    history_error(N_("Error writing %s: %s"), nanohist,
+		strerror(errno));
+	else {
+	    /* Make sure no one else can read from or write to the
+	     * history file. */
+	    chmod(nanohist, S_IRUSR | S_IWUSR);
+
+	    if (!writehist(hist, searchage) || !writehist(hist,
+		replaceage))
+		history_error(N_("Error writing %s: %s"), nanohist,
+			strerror(errno));
+
+	    fclose(hist);
+	}
+
+	free(nanohist);
+    }
+}
+
+
+/* Analogs for the POS history */
+void save_poshistory(void)
+{
+    char *poshist;
+    char *statusstr = NULL;
+    poshiststruct *posptr;
+
+    poshist = poshistfilename();
+
+    if (poshist != NULL) {
+	FILE *hist = fopen(poshist, "wb");
+
+	if (hist == NULL)
+	    history_error(N_("Error writing %s: %s"), poshist,
+		strerror(errno));
+	else {
+	    /* Make sure no one else can read from or write to the
+	     * history file. */
+	    chmod(poshist, S_IRUSR | S_IWUSR);
+
+            for (posptr = poshistory; posptr != NULL; posptr = posptr->next) {
+		statusstr = charalloc(strlen(posptr->filename) + 2 * sizeof(ssize_t) + 4);
+		sprintf(statusstr, "%s %d %d\n", posptr->filename, (int) posptr->lineno,
+			(int) posptr->xno);
+		if (fwrite(statusstr, sizeof(char), strlen(statusstr), hist) < strlen(statusstr))
+		    history_error(N_("Error writing %s: %s"), poshist,
+			strerror(errno));
+		free(statusstr);
+	    }
+	    fclose(hist);
+	}
+	free(poshist);
+    }
+}
+
+/* Update the POS history, given a filename line and column.
+ * If no entry is found, add a new entry on the end
+ */
+void update_poshistory(char *filename, ssize_t lineno, ssize_t xpos)
+{
+   poshiststruct *posptr, *posprev = NULL;
+   char *fullpath = get_full_path(filename);
+
+    if (fullpath == NULL)
+        return;
+
+    for (posptr = poshistory; posptr != NULL; posptr = posptr->next) {
+        if (!strcmp(posptr->filename, fullpath)) {
+	    posptr->lineno = lineno;
+	    posptr->xno = xpos;
+            return;
+        }
+	posprev = posptr;
+    }
+
+    /* Didn't find it, make a new node yo! */
+
+    posptr = (poshiststruct *) nmalloc(sizeof(poshiststruct));
+    posptr->filename = mallocstrcpy(NULL, fullpath);
+    posptr->lineno = lineno;
+    posptr->xno = xpos;
+    posptr->next = NULL;
+
+    if (!poshistory)
+	poshistory = posptr;
+    else
+	posprev->next = posptr;
+
+    free(fullpath);
+}
+
+
+/* Check the POS history to see if file matches
+ * an existing entry.  If so return 1 and set line and column
+ * to the right values  Otherwise return 0
+ */
+int check_poshistory(const char *file, ssize_t *line, ssize_t *column)
+{
+    poshiststruct *posptr;
+    char *fullpath = get_full_path(file);
+
+    if (fullpath == NULL)
+    	return 0;
+
+    for (posptr = poshistory; posptr != NULL; posptr = posptr->next) {
+	if (!strcmp(posptr->filename, fullpath)) {
+	    *line = posptr->lineno;
+	    *column = posptr->xno;
+	    free(fullpath);
+	    return 1;
+	}
+    }
+    free(fullpath);
+    return 0;
+}
+
+
+/* Load histories from ~/.nano_history. */
+void load_poshistory(void)
+{
+    char *nanohist = poshistfilename();
+
+    /* Assume do_rcfile() has reported a missing home directory. */
+    if (nanohist != NULL) {
+	FILE *hist = fopen(nanohist, "rb");
+
+	if (hist == NULL) {
+	    if (errno != ENOENT) {
+		/* Don't save history when we quit. */
+		UNSET(HISTORYLOG);
+		history_error(N_("Error reading %s: %s"), nanohist,
+			strerror(errno));
+	    }
+	} else {
+	    char *line = NULL, *lineptr, *xptr;
+	    size_t buf_len = 0;
+	    ssize_t read, lineno, xno;
+	    poshiststruct *posptr;
+
+	    /* See if we can find the file we're currently editing */
+	    while ((read = getline(&line, &buf_len, hist)) >= 0) {
+		if (read > 0 && line[read - 1] == '\n') {
+		    read--;
+		    line[read] = '\0';
+		}
+		if (read > 0) {
+		    unsunder(line, read);
+		}
+		lineptr = parse_next_word(line);
+		xptr = parse_next_word(lineptr);
+		lineno = atoi(lineptr);
+		xno = atoi(xptr);
+		if (poshistory == NULL) {
+		    poshistory = (poshiststruct *) nmalloc(sizeof(poshiststruct));
+		    poshistory->filename = mallocstrcpy(NULL, line);
+		    poshistory->lineno = lineno;
+		    poshistory->xno = xno;
+		    poshistory->next = NULL;
+		} else {
+		    for (posptr = poshistory; posptr->next != NULL; posptr = posptr->next)
+			;
+		    posptr->next = (poshiststruct *) nmalloc(sizeof(poshiststruct));
+		    posptr->next->filename = mallocstrcpy(NULL, line);
+		    posptr->next->lineno = lineno;
+		    posptr->next->xno = xno;
+		    posptr->next->next = NULL;
+		}
+
+	    }
+
+	    fclose(hist);
+	    free(line);
+	}
+	free(nanohist);
+    }
+}
+
+#endif /* !NANO_TINY && ENABLE_NANORC */
diff --git a/src/global.c b/src/global.c
new file mode 100644
index 0000000..b37563b
--- /dev/null
+++ b/src/global.c
@@ -0,0 +1,1730 @@
+/* $Id: global.c 4535 2011-02-26 14:22:37Z astyanax $ */
+/**************************************************************************
+ *   global.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 <ctype.h>
+#include <string.h>
+#include <strings.h>
+#include "assert.h"
+
+/* Global variables. */
+#ifndef NANO_TINY
+sigjmp_buf jump_buf;
+	/* Used to return to either main() or the unjustify routine in
+	 * do_justify() after a SIGWINCH. */
+bool jump_buf_main = FALSE;
+	/* Have we set jump_buf so that we return to main() after a
+	 * SIGWINCH? */
+#endif
+
+#ifndef DISABLE_WRAPJUSTIFY
+ssize_t fill = 0;
+	/* The column where we will wrap lines. */
+ssize_t wrap_at = -CHARS_FROM_EOL;
+	/* The position where we will wrap lines.  fill is equal to this
+	 * if it's greater than zero, and equal to (COLS + this) if it
+	 * isn't. */
+#endif
+
+char *last_search = NULL;
+	/* The last string we searched for. */
+char *last_replace = NULL;
+	/* The last replacement string we searched for. */
+
+unsigned flags[4] = {0, 0, 0, 0};
+	/* Our flag containing the states of all global options. */
+WINDOW *topwin;
+	/* The top portion of the window, where we display the version
+	 * number of nano, the name of the current file, and whether the
+	 * current file has been modified. */
+WINDOW *edit;
+	/* The middle portion of the window, i.e. the edit window, where
+	 * we display the current file we're editing. */
+WINDOW *bottomwin;
+	/* The bottom portion of the window, where we display statusbar
+	 * messages, the statusbar prompt, and a list of shortcuts. */
+int editwinrows = 0;
+	/* How many rows does the edit window take up? */
+int maxrows = 0;
+	/* How many usable lines are there (due to soft wrapping) */
+
+filestruct *cutbuffer = NULL;
+	/* The buffer where we store cut text. */
+filestruct *cutbottom = NULL;
+#ifndef DISABLE_JUSTIFY
+filestruct *jusbuffer = NULL;
+	/* The buffer where we store unjustified text. */
+#endif
+partition *filepart = NULL;
+	/* The partition where we store a portion of the current
+	 * file. */
+openfilestruct *openfile = NULL;
+	/* The list of all open file buffers. */
+
+#ifndef NANO_TINY
+char *matchbrackets = NULL;
+	/* The opening and closing brackets that can be found by bracket
+	 * searches. */
+#endif
+
+#if !defined(NANO_TINY) && defined(ENABLE_NANORC)
+char *whitespace = NULL;
+	/* The characters used when displaying the first characters of
+	 * tabs and spaces. */
+int whitespace_len[2];
+	/* The length of these characters. */
+#endif
+
+#ifndef DISABLE_JUSTIFY
+char *punct = NULL;
+	/* The closing punctuation that can end sentences. */
+char *brackets = NULL;
+	/* The closing brackets that can follow closing punctuation and
+	 * can end sentences. */
+char *quotestr = NULL;
+	/* The quoting string.  The default value is set in main(). */
+#ifdef HAVE_REGEX_H
+regex_t quotereg;
+	/* The compiled regular expression from the quoting string. */
+int quoterc;
+	/* Whether it was compiled successfully. */
+char *quoteerr = NULL;
+	/* The error message, if it didn't. */
+#else
+size_t quotelen;
+	/* The length of the quoting string in bytes. */
+#endif
+#endif
+
+bool nodelay_mode = FALSE;
+	/* Are we in nodelay mode (checking for a cancel wile doing something */
+
+char *answer = NULL;
+	/* The answer string used by the statusbar prompt. */
+
+ssize_t tabsize = -1;
+	/* The width of a tab in spaces.  The default value is set in
+	 * main(). */
+
+#ifndef NANO_TINY
+char *backup_dir = NULL;
+	/* The directory where we store backup files. */
+#endif
+#ifndef DISABLE_OPERATINGDIR
+char *operating_dir = NULL;
+	/* The relative path to the operating directory, which we can't
+	 * move outside of. */
+char *full_operating_dir = NULL;
+	/* The full path to it. */
+#endif
+
+#ifndef DISABLE_SPELLER
+char *alt_speller = NULL;
+	/* The command to use for the alternate spell checker. */
+#endif
+
+#ifdef ENABLE_COLOR
+syntaxtype *syntaxes = NULL;
+	/* The global list of color syntaxes. */
+char *syntaxstr = NULL;
+	/* The color syntax name specified on the command line. */
+
+#endif
+
+bool edit_refresh_needed = 0;
+	/* Did a command mangle enough of the buffer refresh that we 
+	   should repaint the screen */
+
+const shortcut *currshortcut;
+	/* The current shortcut list we're using. */
+int currmenu;
+	/* The currently loaded menu */
+
+sc *sclist = NULL;
+	/* New shortcut key struct */
+subnfunc *allfuncs = NULL;
+	/* New struct for the function list */
+
+#ifndef NANO_TINY
+filestruct *search_history = NULL;
+	/* The search string history list. */
+filestruct *searchage = NULL;
+	/* The top of the search string history list. */
+filestruct *searchbot = NULL;
+	/* The bottom of the search string history list. */
+filestruct *replace_history = NULL;
+	/* The replace string history list. */
+filestruct *replaceage = NULL;
+	/* The top of the replace string history list. */
+filestruct *replacebot = NULL;
+	/* The bottom of the replace string history list. */
+poshiststruct *poshistory;
+	/* The cursor position history list  */
+#endif
+
+/* Regular expressions. */
+#ifdef HAVE_REGEX_H
+regex_t search_regexp;
+	/* The compiled regular expression to use in searches. */
+regmatch_t regmatches[10];
+	/* The match positions for parenthetical subexpressions, 10
+	 * maximum, used in regular expression searches. */
+#endif
+
+int reverse_attr = A_REVERSE;
+	/* The curses attribute we use for reverse video. */
+
+char *homedir = NULL;
+	/* The user's home directory, from $HOME or /etc/passwd. */
+
+/* Return the number of entries in the shortcut list s for a given menu. */
+size_t length_of_list(int menu)
+{
+    subnfunc *f;
+    size_t i = 0;
+
+    for (f = allfuncs; f != NULL; f = f->next)
+        if ((f->menus & menu) != 0
+#ifndef DISABLE_HELP
+	    && strlen(f->help) > 0
+#endif
+	                          ) {
+	    i++;
+	}
+    return i;
+}
+
+/* Just throw this here */
+void case_sens_void(void)
+{
+}
+void regexp_void(void)
+{
+}
+void gototext_void(void)
+{
+}
+void to_files_void(void)
+{
+}
+void dos_format_void(void)
+{
+}
+void mac_format_void(void)
+{
+}
+void append_void(void)
+{
+}
+void prepend_void(void)
+{
+}
+void backup_file_void(void)
+{
+}
+void new_buffer_void(void)
+{
+}
+void backwards_void(void)
+{
+}
+void goto_dir_void(void)
+{
+}
+void no_replace_void(void)
+{
+}
+void ext_cmd_void(void)
+{
+}
+
+/* Set type of function based on the string */
+function_type strtokeytype(const char *str)
+{
+    if (str[0] ==  'M' || str[0] == 'm')
+        return META;
+    else if (str[0] == '^')
+        return CONTROL;
+    else if (str[0] ==  'F' || str[0] == 'F')
+        return FKEY;
+    else
+	return RAWINPUT;
+}
+
+/* Add a string to the new function list strict.
+   Does not allow updates, yet anyway */
+void add_to_funcs(void (*func)(void), int menus, const char *desc, const char *help,
+    bool blank_after, bool viewok)
+{
+    subnfunc *f;
+
+    if (allfuncs == NULL) {
+	allfuncs = (subnfunc *) nmalloc(sizeof(subnfunc));
+	f = allfuncs;
+    } else {
+	for (f = allfuncs; f->next != NULL; f = f->next)
+		;
+        f->next = (subnfunc *)nmalloc(sizeof(subnfunc));
+        f = f->next;
+    }
+    f->next = NULL;
+    f->scfunc = func;
+    f->menus = menus;
+    f->desc = desc;
+    f->viewok = viewok;
+#ifndef DISABLE_HELP
+    f->help = help;
+    f->blank_after = blank_after;
+#endif
+
+#ifdef DEBUG
+    fprintf(stderr, "Added func \"%s\"", f->desc);
+#endif
+}
+
+const sc *first_sc_for(int menu, void (*func)(void)) {
+    const sc *s;
+    const sc *metasc = NULL;
+
+    for (s = sclist; s != NULL; s = s->next) {
+	if ((s->menu & menu) && s->scfunc == func) {
+	    /* try to use a meta sequence as a last resort.  Otherwise
+	       we will run into problems when we try and handle things like
+	       the arrow keys, home, etc, if for some reason the user bound
+	       them to a meta sequence first *shrug* */
+	    if (s->type == META) {
+		metasc = s;
+		continue;
+	    } /* otherwise it was something else, use it */
+	    return s;
+	}
+    }
+
+    /* If we're here we may have found only meta sequences, if so use one */
+    if (metasc)
+	return metasc;
+
+#ifdef DEBUG
+    fprintf(stderr, "Whoops, returning null given func %ld in menu %d\n", (long) func, menu);
+#endif
+    /* Otherwise... */
+    return NULL;
+}
+
+
+/* Add a string to the new shortcut list implementation
+   Allows updates to existing entries in the list */
+void add_to_sclist(int menu, const char *scstring, void (*func)(void), int toggle, int execute)
+{
+    sc *s;
+
+    if (sclist == NULL) {
+	sclist = (sc *) nmalloc(sizeof(sc));
+	s = sclist;
+        s->next = NULL;
+    } else {
+	for (s = sclist; s->next != NULL; s = s->next)
+            if (s->menu == menu && s->keystr == scstring)
+		break;
+
+        if (s->menu != menu || s->keystr != scstring) { /* i.e. this is not a replace... */
+#ifdef DEBUG
+            fprintf(stderr, "No match found...\n");
+#endif
+	    s->next = (sc *)nmalloc(sizeof(sc));
+	    s = s->next;
+            s->next = NULL;
+        }
+    }
+
+    s->type = strtokeytype(scstring);
+    s->menu = menu;
+    s->toggle = toggle;
+    s->keystr = (char *) scstring;
+    s->scfunc = func;
+    s->execute = execute;
+    assign_keyinfo(s);
+
+#ifdef DEBUG
+    fprintf(stderr, "list val = %d\n", (int) s->menu);
+    fprintf(stderr, "Hey, set sequence to %d for shortcut \"%s\"\n", s->seq, scstring);
+#endif
+}
+
+/* Return the given menu's first shortcut sequence, or the default value
+  (2nd arg).  Assumes currmenu for the menu to check*/
+int sc_seq_or (void (*func)(void), int defaultval) 
+{
+    const sc *s = first_sc_for(currmenu, func);
+
+    if (s)
+        return s->seq;
+    /* else */
+    return defaultval;
+
+}
+
+/* Assign the info to the shortcut struct 
+   Assumes keystr is already assigned, naturally */
+void assign_keyinfo(sc *s)
+{
+    if (s->type == CONTROL) {
+        assert(strlen(s->keystr) > 1);
+        s->seq = s->keystr[1] - 64;
+    } else if (s->type == META) {
+        assert(strlen(s->keystr) > 2);
+        s->seq = tolower((int) s->keystr[2]);
+    } else if (s->type == FKEY) {
+        assert(strlen(s->keystr) > 1);
+        s->seq = KEY_F0 + atoi(&s->keystr[1]);
+    } else /* RAWINPUT */
+        s->seq = (int) s->keystr[0];
+
+    /* Override some keys which don't bind as nicely as we'd like */
+    if (s->type == CONTROL && (!strcasecmp(&s->keystr[1], "space")))
+	s->seq = 0;
+    else if (s->type == META && (!strcasecmp(&s->keystr[2], "space")))
+	s->seq = (int) ' ';
+    else if (s->type == RAWINPUT && (!strcasecmp(s->keystr, "kup")))
+	s->seq = KEY_UP;
+    else if (s->type == RAWINPUT && (!strcasecmp(s->keystr, "kdown")))
+	s->seq = KEY_DOWN;
+    else if (s->type == RAWINPUT && (!strcasecmp(s->keystr, "kleft")))
+	s->seq = KEY_LEFT;
+    else if (s->type == RAWINPUT && (!strcasecmp(s->keystr, "kright")))
+	s->seq = KEY_RIGHT;
+    else if (s->type == RAWINPUT && (!strcasecmp(s->keystr, "kinsert")))
+	s->seq = KEY_IC;
+    else if (s->type == RAWINPUT && (!strcasecmp(s->keystr, "kdel")))
+	s->seq = KEY_DC;
+    else if (s->type == RAWINPUT && (!strcasecmp(s->keystr, "kbsp")))
+	s->seq = KEY_BACKSPACE;
+    else if (s->type == RAWINPUT && (!strcasecmp(s->keystr, "kenter")))
+	s->seq = KEY_ENTER;
+    else if (s->type == RAWINPUT && (!strcasecmp(s->keystr, "kpup")))
+	s->seq = KEY_PPAGE;
+    else if (s->type == RAWINPUT && (!strcasecmp(s->keystr, "kpdown")))
+	s->seq = KEY_NPAGE;
+#ifdef KEY_HOME
+    else if (s->type == RAWINPUT && (!strcasecmp(s->keystr, "khome")))
+	s->seq = KEY_HOME;
+#endif
+#ifdef KEY_END
+    else if (s->type == RAWINPUT && (!strcasecmp(s->keystr, "kend")))
+	s->seq = KEY_END;
+#endif
+
+}
+
+#ifdef DEBUG
+
+void print_sclist(void)
+{
+    sc *s;
+    const subnfunc *f;
+
+    for (s = sclist; s->next != NULL; s = s->next) {
+	f = sctofunc(s);
+        if (f)
+	    fprintf(stderr, "Shortcut \"%s\", function: %s, menus %d\n",  s->keystr, f->desc, f->menus);
+	else
+	    fprintf(stderr, "Hmm, didnt find a func for \"%s\"\n", s->keystr);
+    }
+
+}
+#endif
+
+
+/* Stuff we need to make at least static here so we can access it below */
+/* TRANSLATORS: Try to keep the next five strings at most 10 characters. */
+const char *cancel_msg = N_("Cancel");
+const char *replace_msg = N_("Replace");
+const char *no_replace_msg = N_("No Replace");
+
+#ifndef NANO_TINY
+const char *case_sens_msg = N_("Case Sens");
+const char *backwards_msg = N_("Backwards");
+#endif
+
+#ifdef HAVE_REGEX_H
+const char *regexp_msg = N_("Regexp");
+#endif
+
+/* Stuff we want to just stun out if we're in TINY mode */
+#ifdef NANO_TINY
+const char *gototext_msg = "";
+const char *do_para_begin_msg = "";
+const char *do_para_end_msg = "";
+const char *case_sens_msg = "";
+const char *backwards_msg = "";
+const char *do_cut_till_end = "";
+const char *dos_format_msg = "";
+const char *mac_format_msg = "";
+const char *append_msg = "";
+const char *prepend_msg = "";
+const char *backup_file_msg = "";
+const char *to_files_msg = "";
+const char *first_file_msg = "";
+const char *whereis_next_msg = "";
+const char *last_file_msg = "";
+const char *new_buffer_msg = "";
+const char *goto_dir_msg;
+const char *ext_cmd_msg = "";
+
+#else
+/* TRANSLATORS: Try to keep the next five strings at most 10 characters. */
+const char *prev_history_msg = N_("PrevHstory");
+const char *next_history_msg = N_("NextHstory");
+const char *gototext_msg = N_("Go To Text");
+/* TRANSLATORS: Try to keep the next three strings at most 12 characters. */
+const char *whereis_next_msg = N_("WhereIs Next");
+#ifndef DISABLE_BROWSER
+const char *first_file_msg = N_("First File");
+const char *last_file_msg = N_("Last File");
+/* TRANSLATORS: Try to keep the next nine strings at most 16 characters. */
+const char *to_files_msg = N_("To Files");
+#endif
+const char *dos_format_msg = N_("DOS Format");
+const char *mac_format_msg = N_("Mac Format");
+const char *append_msg = N_("Append");
+const char *prepend_msg = N_("Prepend");
+const char *backup_file_msg = N_("Backup File");
+const char *ext_cmd_msg = N_("Execute Command");
+#ifdef ENABLE_MULTIBUFFER
+const char *new_buffer_msg = N_("New Buffer");
+#endif
+const char *goto_dir_msg = N_("Go To Dir");
+
+#endif /* NANO_TINY */
+
+/* Initialize all shortcut lists.  If unjustify is TRUE, replace the
+ * Uncut shortcut in the main shortcut list with UnJustify. */
+void shortcut_init(bool unjustify)
+{
+    /* TRANSLATORS: Try to keep the following strings at most 10 characters. */
+    const char *get_help_msg = N_("Get Help");
+    const char *exit_msg = N_("Exit");
+    const char *whereis_msg = N_("Where Is");
+    const char *prev_page_msg = N_("Prev Page");
+    const char *next_page_msg = N_("Next Page");
+    const char *first_line_msg = N_("First Line");
+    const char *last_line_msg = N_("Last Line");
+    const char *suspend_msg = N_("Suspend");
+#ifndef DISABLE_JUSTIFY
+    const char *beg_of_par_msg = N_("Beg of Par");
+    const char *end_of_par_msg = N_("End of Par");
+    const char *fulljstify_msg = N_("FullJstify");
+#endif
+    const char *refresh_msg = N_("Refresh");
+#ifndef NANO_TINY
+    const char *insert_file_msg =  N_("Insert File");
+#endif
+    const char *go_to_line_msg = N_("Go To Line");
+
+#ifndef DISABLE_JUSTIFY
+    const char *nano_justify_msg = N_("Justify the current paragraph");
+#endif
+#ifndef DISABLE_HELP
+    /* TRANSLATORS: The next long series of strings are shortcut descriptions;
+     * they are best kept shorter than 56 characters, but may be longer. */
+    const char *nano_cancel_msg = N_("Cancel the current function");
+    const char *nano_help_msg = N_("Display this help text");
+    const char *nano_exit_msg =
+#ifdef ENABLE_MULTIBUFFER
+	N_("Close the current file buffer / Exit from nano")
+#else
+   	N_("Exit from nano")
+#endif
+	;
+    const char *nano_writeout_msg =
+	N_("Write the current file to disk");
+    const char *nano_insert_msg =
+	N_("Insert another file into the current one");
+    const char *nano_whereis_msg =
+	N_("Search for a string or a regular expression");
+    const char *nano_prevpage_msg = N_("Go to previous screen");
+    const char *nano_nextpage_msg = N_("Go to next screen");
+    const char *nano_cut_msg =
+	N_("Cut the current line and store it in the cutbuffer");
+    const char *nano_uncut_msg =
+	N_("Uncut from the cutbuffer into the current line");
+    const char *nano_cursorpos_msg =
+	N_("Display the position of the cursor");
+    const char *nano_spell_msg =
+	N_("Invoke the spell checker, if available");
+    const char *nano_replace_msg =
+	N_("Replace a string or a regular expression");
+     const char *nano_gotoline_msg = N_("Go to line and column number");
+#ifndef NANO_TINY
+    const char *nano_mark_msg = N_("Mark text at the cursor position");
+    const char *nano_whereis_next_msg = N_("Repeat last search");
+    const char *nano_copy_msg =
+	N_("Copy the current line and store it in the cutbuffer");
+    const char *nano_indent_msg = N_("Indent the current line");
+    const char *nano_unindent_msg = N_("Unindent the current line");
+    const char *nano_undo_msg = N_("Undo the last operation");
+    const char *nano_redo_msg = N_("Redo the last undone operation");
+#endif
+    const char *nano_forward_msg = N_("Go forward one character");
+    const char *nano_back_msg = N_("Go back one character");
+#ifndef NANO_TINY
+    const char *nano_nextword_msg = N_("Go forward one word");
+    const char *nano_prevword_msg = N_("Go back one word");
+#endif
+    const char *nano_prevline_msg = N_("Go to previous line");
+    const char *nano_nextline_msg = N_("Go to next line");
+    const char *nano_home_msg = N_("Go to beginning of current line");
+    const char *nano_end_msg = N_("Go to end of current line");
+#ifndef DISABLE_JUSTIFY
+    const char *nano_parabegin_msg =
+	N_("Go to beginning of paragraph; then of previous paragraph");
+    const char *nano_paraend_msg =
+	N_("Go just beyond end of paragraph; then of next paragraph");
+#endif
+    const char *nano_firstline_msg =
+	N_("Go to the first line of the file");
+    const char *nano_lastline_msg =
+	N_("Go to the last line of the file");
+#ifndef NANO_TINY
+    const char *nano_bracket_msg = N_("Go to the matching bracket");
+    const char *nano_scrollup_msg =
+	N_("Scroll up one line without scrolling the cursor");
+    const char *nano_scrolldown_msg =
+	N_("Scroll down one line without scrolling the cursor");
+#endif
+#ifdef ENABLE_MULTIBUFFER
+    const char *nano_prevfile_msg =
+	N_("Switch to the previous file buffer");
+    const char *nano_nextfile_msg =
+	N_("Switch to the next file buffer");
+#endif
+    const char *nano_verbatim_msg =
+	N_("Insert the next keystroke verbatim");
+    const char *nano_tab_msg =
+	N_("Insert a tab at the cursor position");
+    const char *nano_enter_msg =
+	N_("Insert a newline at the cursor position");
+    const char *nano_delete_msg =
+	N_("Delete the character under the cursor");
+    const char *nano_backspace_msg =
+	N_("Delete the character to the left of the cursor");
+#ifndef NANO_TINY
+    const char *nano_cut_till_end_msg =
+	N_("Cut from the cursor position to the end of the file");
+#endif
+#ifndef DISABLE_JUSTIFY
+    const char *nano_fulljustify_msg = N_("Justify the entire file");
+#endif
+#ifndef NANO_TINY
+    const char *nano_wordcount_msg =
+	N_("Count the number of words, lines, and characters");
+#endif
+    const char *nano_refresh_msg =
+	N_("Refresh (redraw) the current screen");
+    const char *nano_suspend_msg =
+	N_("Suspend the editor (if suspend is enabled)");
+#ifndef NANO_TINY
+    const char *nano_case_msg =
+	N_("Toggle the case sensitivity of the search");
+    const char *nano_reverse_msg =
+	N_("Reverse the direction of the search");
+#endif
+#ifdef HAVE_REGEX_H
+    const char *nano_regexp_msg =
+	N_("Toggle the use of regular expressions");
+#endif
+#ifndef NANO_TINY
+    const char *nano_prev_history_msg =
+	N_("Recall the previous search/replace string");
+    const char *nano_next_history_msg =
+	N_("Recall the next search/replace string");
+#endif
+#ifndef DISABLE_BROWSER
+    const char *nano_tofiles_msg = N_("Go to file browser");
+#endif
+#ifndef NANO_TINY
+    const char *nano_dos_msg = N_("Toggle the use of DOS format");
+    const char *nano_mac_msg = N_("Toggle the use of Mac format");
+#endif
+    const char *nano_append_msg = N_("Toggle appending");
+    const char *nano_prepend_msg = N_("Toggle prepending");
+#ifndef NANO_TINY
+    const char *nano_backup_msg =
+	N_("Toggle backing up of the original file");
+    const char *nano_execute_msg = N_("Execute external command");
+#endif
+#if !defined(NANO_TINY) && defined(ENABLE_MULTIBUFFER)
+    const char *nano_multibuffer_msg =
+	N_("Toggle the use of a new buffer");
+#endif
+#ifndef DISABLE_BROWSER
+    const char *nano_exitbrowser_msg = N_("Exit from the file browser");
+    const char *nano_firstfile_msg =
+	N_("Go to the first file in the list");
+    const char *nano_lastfile_msg =
+	N_("Go to the last file in the list");
+    const char *nano_forwardfile_msg = N_("Go to the next file in the list");
+    const char *nano_backfile_msg = N_("Go to the previous file in the list");
+    const char *nano_gotodir_msg = N_("Go to directory");
+#endif
+#endif /* !DISABLE_HELP */
+
+#ifndef DISABLE_HELP
+#define IFSCHELP(help) help
+#else
+#define IFSCHELP(help) ""
+#endif
+
+    while (allfuncs != NULL) {
+        subnfunc *f = allfuncs;
+        allfuncs = (allfuncs)->next;
+        free(f);
+    }
+
+    add_to_funcs(do_help_void,
+	(MMAIN|MWHEREIS|MREPLACE|MREPLACE2|MGOTOLINE|MWRITEFILE|MINSERTFILE|MEXTCMD|MSPELL|MBROWSER|MWHEREISFILE|MGOTODIR),
+	get_help_msg, IFSCHELP(nano_help_msg), FALSE, VIEW);
+
+    add_to_funcs( do_cancel,
+	(MWHEREIS|MREPLACE|MREPLACE2|MGOTOLINE|MWRITEFILE|MINSERTFILE|MEXTCMD|MSPELL|MWHEREISFILE|MGOTODIR|MYESNO),
+	cancel_msg, IFSCHELP(nano_cancel_msg), FALSE, VIEW);
+
+    add_to_funcs(do_exit, MMAIN,
+#ifdef ENABLE_MULTIBUFFER
+	/* TRANSLATORS: Try to keep this at most 10 characters. */
+	openfile != NULL && openfile != openfile->next ? N_("Close") :
+#endif
+	exit_msg, IFSCHELP(nano_exit_msg), FALSE, VIEW);
+
+#ifndef DISABLE_BROWSER
+    add_to_funcs(do_exit, MBROWSER, exit_msg, IFSCHELP(nano_exitbrowser_msg), FALSE, VIEW);
+#endif
+
+    /* TRANSLATORS: Try to keep this at most 10 characters. */
+    add_to_funcs(do_writeout_void, MMAIN, N_("WriteOut"),
+	IFSCHELP(nano_writeout_msg), FALSE, NOVIEW);
+
+#ifndef DISABLE_JUSTIFY
+    /* TRANSLATORS: Try to keep this at most 10 characters. */
+    add_to_funcs(do_justify_void, MMAIN, N_("Justify"),
+	nano_justify_msg, TRUE, NOVIEW);
+#endif
+
+    /* We allow inserting files in view mode if multibuffers are
+     * available, so that we can view multiple files.  If we're using
+     * restricted mode, inserting files is disabled, since it allows
+     * reading from or writing to files not specified on the command
+     * line. */
+
+    add_to_funcs(do_insertfile_void,
+	/* TRANSLATORS: Try to keep this at most 10 characters. */
+	MMAIN, N_("Read File"), IFSCHELP(nano_insert_msg), FALSE,
+#ifdef ENABLE_MULTIBUFFER
+	VIEW);
+#else
+	NOVIEW);
+#endif
+
+    add_to_funcs(do_search, MMAIN|MBROWSER, whereis_msg,
+	IFSCHELP(nano_whereis_msg), FALSE, VIEW);
+
+    add_to_funcs(do_page_up, MMAIN|MHELP|MBROWSER,
+	prev_page_msg, IFSCHELP(nano_prevpage_msg), FALSE, VIEW);
+    add_to_funcs(do_page_down, MMAIN|MHELP|MBROWSER,
+	next_page_msg, IFSCHELP(nano_nextpage_msg), TRUE, VIEW);
+
+
+    /* TRANSLATORS: Try to keep this at most 10 characters. */
+    add_to_funcs(do_cut_text_void, MMAIN, N_("Cut Text"), IFSCHELP(nano_cut_msg),
+	FALSE, NOVIEW);
+
+    if (unjustify)
+	/* TRANSLATORS: Try to keep this at most 10 characters. */
+	add_to_funcs(do_uncut_text, MMAIN, N_("UnJustify"), "",
+	    FALSE, NOVIEW);
+
+    else
+	/* TRANSLATORS: Try to keep this at most 10 characters. */
+	add_to_funcs(do_uncut_text, MMAIN, N_("UnCut Text"), IFSCHELP(nano_uncut_msg),
+	    FALSE, NOVIEW);
+
+#ifndef NANO_TINY
+    /* TRANSLATORS: Try to keep this at most 10 characters. */
+    add_to_funcs(do_cursorpos_void, MMAIN, N_("Cur Pos"), IFSCHELP(nano_cursorpos_msg),
+	FALSE, VIEW);
+#endif
+
+    /* If we're using restricted mode, spell checking is disabled
+     * because it allows reading from or writing to files not specified
+     * on the command line. */
+#ifndef DISABLE_SPELLER
+	/* TRANSLATORS: Try to keep this at most 10 characters. */
+	add_to_funcs(do_spell, MMAIN, N_("To Spell"), IFSCHELP(nano_spell_msg),
+	    TRUE, NOVIEW);
+#endif
+
+    add_to_funcs(do_first_line,
+	(MMAIN|MWHEREIS|MREPLACE|MREPLACE2|MGOTOLINE),
+	first_line_msg, IFSCHELP(nano_firstline_msg), FALSE, VIEW);
+
+    add_to_funcs(do_last_line,
+	(MMAIN|MWHEREIS|MREPLACE|MREPLACE2|MGOTOLINE),
+	last_line_msg, IFSCHELP(nano_lastline_msg), TRUE, VIEW);
+
+
+    add_to_funcs(do_gotolinecolumn_void, (MMAIN|MWHEREIS),
+	go_to_line_msg, IFSCHELP(nano_gotoline_msg), FALSE, VIEW);
+
+#ifdef NANO_TINY
+    /* TRANSLATORS: Try to keep this at most 10 characters. */
+    add_to_funcs(do_cursorpos_void, MMAIN, N_("Cur Pos"), IFSCHELP(nano_cursorpos_msg),
+	FALSE, VIEW);
+#endif
+
+
+    add_to_funcs(do_replace, (MMAIN|MWHEREIS), replace_msg, IFSCHELP(nano_replace_msg),
+
+#ifndef NANO_TINY
+	FALSE,
+#else
+	TRUE,
+#endif
+	NOVIEW);
+
+#ifndef NANO_TINY
+
+    add_to_funcs(do_mark, MMAIN, N_("Mark Text"), 
+	IFSCHELP(nano_mark_msg), FALSE, VIEW);
+
+    add_to_funcs(do_research, (MMAIN|MBROWSER), whereis_next_msg,
+	IFSCHELP(nano_whereis_next_msg), TRUE, VIEW);
+
+    add_to_funcs(do_copy_text, MMAIN, N_("Copy Text"),
+	IFSCHELP(nano_copy_msg), FALSE, NOVIEW);
+
+    add_to_funcs(do_indent_void, MMAIN, N_("Indent Text"),
+	IFSCHELP(nano_indent_msg), FALSE, NOVIEW);
+
+    add_to_funcs(do_unindent, MMAIN, N_("Unindent Text"),
+	IFSCHELP(nano_unindent_msg), FALSE, NOVIEW);
+
+    if (ISSET(UNDOABLE)) {
+	add_to_funcs(do_undo, MMAIN, N_("Undo"),
+	    IFSCHELP(nano_undo_msg), FALSE, NOVIEW);
+
+	add_to_funcs(do_redo, MMAIN, N_("Redo"),
+	    IFSCHELP(nano_redo_msg), TRUE, NOVIEW);
+    }
+
+#endif
+
+    add_to_funcs(do_right, MMAIN, N_("Forward"), IFSCHELP(nano_forward_msg),
+	FALSE, VIEW);
+
+#ifndef DISABLE_BROWSER
+    add_to_funcs(do_right, MBROWSER, N_("Forward"), IFSCHELP(nano_forwardfile_msg),
+	FALSE, VIEW);
+#endif
+
+    add_to_funcs(do_right, MALL, "", "", FALSE, VIEW);
+
+    add_to_funcs(do_left, MMAIN, N_("Back"), IFSCHELP(nano_back_msg),
+	FALSE, VIEW);
+
+#ifndef DISABLE_BROWSER
+    add_to_funcs(do_left, MBROWSER, N_("Back"), IFSCHELP(nano_backfile_msg),
+	FALSE, VIEW);
+#endif
+
+    add_to_funcs(do_left, MALL, "", "", FALSE, VIEW);
+
+#ifndef NANO_TINY
+    add_to_funcs(do_next_word_void, MMAIN, N_("Next Word"),
+	IFSCHELP(nano_nextword_msg), FALSE, VIEW);
+
+    add_to_funcs(do_prev_word_void, MMAIN, N_("Prev Word"),
+	IFSCHELP(nano_prevword_msg), FALSE, VIEW);
+#endif
+
+    add_to_funcs(do_up_void, (MMAIN|MHELP|MBROWSER), N_("Prev Line"),
+	IFSCHELP(nano_prevline_msg), FALSE, VIEW);
+
+    add_to_funcs(do_down_void, (MMAIN|MHELP|MBROWSER), N_("Next Line"),
+	IFSCHELP(nano_nextline_msg), TRUE, VIEW);
+
+    add_to_funcs(do_home, MMAIN, N_("Home"), IFSCHELP(nano_home_msg),
+	FALSE, VIEW);
+
+    add_to_funcs(do_end, MMAIN, N_("End"), IFSCHELP(nano_end_msg),
+	FALSE, VIEW);
+
+#ifndef DISABLE_JUSTIFY
+    add_to_funcs(do_para_begin_void, (MMAIN|MWHEREIS), beg_of_par_msg,
+	IFSCHELP(nano_parabegin_msg), FALSE, VIEW);
+
+    add_to_funcs(do_para_end_void, (MMAIN|MWHEREIS), end_of_par_msg,
+	IFSCHELP(nano_paraend_msg), FALSE, VIEW);
+#endif
+
+#ifndef NANO_TINY
+    add_to_funcs(do_find_bracket, MMAIN, _("Find Other Bracket"),
+	IFSCHELP(nano_bracket_msg), FALSE, VIEW);
+
+    add_to_funcs(do_scroll_up, MMAIN, N_("Scroll Up"),
+	IFSCHELP(nano_scrollup_msg), FALSE, VIEW);
+
+    add_to_funcs(do_scroll_down, MMAIN, N_("Scroll Down"),
+	IFSCHELP(nano_scrolldown_msg), FALSE, VIEW);
+#endif
+
+#ifdef ENABLE_MULTIBUFFER
+    add_to_funcs(switch_to_prev_buffer_void, MMAIN, _("Previous File"),
+	IFSCHELP(nano_prevfile_msg), FALSE, VIEW);
+    add_to_funcs(switch_to_next_buffer_void, MMAIN, N_("Next File"),
+	IFSCHELP(nano_nextfile_msg), TRUE, VIEW);
+#endif
+
+    add_to_funcs(do_verbatim_input, MMAIN, N_("Verbatim Input"),
+	IFSCHELP(nano_verbatim_msg), FALSE, NOVIEW);
+    add_to_funcs(do_verbatim_input, MWHEREIS|MREPLACE|MREPLACE2|MEXTCMD|MSPELL,
+	"", "", FALSE, NOVIEW);
+
+    add_to_funcs(do_tab, MMAIN, N_("Tab"), IFSCHELP(nano_tab_msg),
+	FALSE, NOVIEW);
+    add_to_funcs(do_tab, MALL, "", "", FALSE, NOVIEW);
+    add_to_funcs(do_enter_void, MMAIN, N_("Enter"), IFSCHELP(nano_enter_msg),
+	FALSE, NOVIEW);
+    add_to_funcs(do_enter_void, MALL, "", "", FALSE, NOVIEW);
+    add_to_funcs(do_delete, MMAIN, N_("Delete"), IFSCHELP(nano_delete_msg),
+	FALSE, NOVIEW);
+    add_to_funcs(do_delete, MALL, "", "", FALSE, NOVIEW);
+    add_to_funcs(do_backspace, MMAIN, N_("Backspace"), IFSCHELP(nano_backspace_msg),
+#ifndef NANO_TINY
+	FALSE,
+#else
+	TRUE,
+#endif
+	NOVIEW);
+
+    add_to_funcs(do_backspace, MALL, "", "",
+#ifndef NANO_TINY
+	FALSE,
+#else
+	TRUE,
+#endif
+	NOVIEW);
+
+#ifndef NANO_TINY
+    add_to_funcs(do_cut_till_end, MMAIN, N_("CutTillEnd"),
+	IFSCHELP(nano_cut_till_end_msg), TRUE, NOVIEW);
+#endif
+
+    add_to_funcs(xon_complaint, MMAIN, "", "", FALSE, VIEW);
+    add_to_funcs(xoff_complaint, MMAIN, "", "", FALSE, VIEW);
+
+#ifndef DISABLE_JUSTIFY
+    add_to_funcs(do_full_justify, (MMAIN|MWHEREIS), fulljstify_msg,
+	IFSCHELP(nano_fulljustify_msg), FALSE, NOVIEW);
+#endif
+
+#ifndef NANO_TINY
+    add_to_funcs(do_wordlinechar_count, MMAIN, N_("Word Count"),
+	IFSCHELP(nano_wordcount_msg), FALSE, VIEW);
+#endif
+
+    add_to_funcs(total_refresh, (MMAIN|MHELP), refresh_msg, 
+	IFSCHELP(nano_refresh_msg), FALSE, VIEW);
+
+    add_to_funcs(do_suspend_void, MMAIN, suspend_msg,
+	IFSCHELP(nano_suspend_msg), TRUE, VIEW);
+
+#ifndef NANO_TINY
+    add_to_funcs(case_sens_void,
+	(MWHEREIS|MREPLACE|MWHEREISFILE),
+	case_sens_msg, IFSCHELP(nano_case_msg), FALSE, VIEW);
+
+    add_to_funcs(backwards_void,
+	(MWHEREIS|MREPLACE|MWHEREISFILE),
+	backwards_msg, IFSCHELP(nano_reverse_msg), FALSE, VIEW);
+#endif
+
+#ifdef HAVE_REGEX_H
+    add_to_funcs(regexp_void,
+	(MWHEREIS|MREPLACE|MWHEREISFILE),
+	regexp_msg, IFSCHELP(nano_regexp_msg), FALSE, VIEW);
+#endif
+
+#ifndef NANO_TINY
+    add_to_funcs(get_history_older_void,
+	(MWHEREIS|MREPLACE|MREPLACE2|MWHEREISFILE),
+	prev_history_msg, IFSCHELP(nano_prev_history_msg), FALSE, VIEW);
+
+    add_to_funcs(get_history_newer_void,
+	(MWHEREIS|MREPLACE|MREPLACE2|MWHEREISFILE),
+	next_history_msg, IFSCHELP(nano_next_history_msg), FALSE, VIEW);
+#endif
+
+    add_to_funcs(no_replace_void, MREPLACE,
+	no_replace_msg, IFSCHELP(nano_whereis_msg), FALSE, VIEW);
+
+    add_to_funcs(gototext_void, MGOTOLINE,
+	gototext_msg, IFSCHELP(nano_whereis_msg), TRUE, VIEW);
+
+#ifndef DISABLE_BROWSER
+    if (!ISSET(RESTRICTED))
+	add_to_funcs(to_files_void,
+	    (MGOTOLINE|MINSERTFILE),
+	    to_files_msg, IFSCHELP(nano_tofiles_msg), FALSE, VIEW);
+#endif
+
+#ifndef NANO_TINY
+    /* If we're using restricted mode, the DOS format, Mac format,
+     * append, prepend, and backup toggles are disabled.  The first and
+     * second are useless since inserting files is disabled, the third
+     * and fourth are disabled because they allow writing to files not
+     * specified on the command line, and the fifth is useless since
+     * backups are disabled. */
+    if (!ISSET(RESTRICTED))
+        add_to_funcs(dos_format_void, MWRITEFILE,
+            dos_format_msg, IFSCHELP(nano_dos_msg), FALSE, NOVIEW);
+
+    if (!ISSET(RESTRICTED))
+        add_to_funcs(mac_format_void, MWRITEFILE,
+            mac_format_msg, IFSCHELP(nano_mac_msg), FALSE, NOVIEW);
+
+    if (!ISSET(RESTRICTED))
+        add_to_funcs( append_void, MWRITEFILE,
+            append_msg, IFSCHELP(nano_append_msg), FALSE, NOVIEW);
+
+    if (!ISSET(RESTRICTED))
+        add_to_funcs( prepend_void, MWRITEFILE,
+            prepend_msg, IFSCHELP(nano_prepend_msg), FALSE, NOVIEW);
+
+    if (!ISSET(RESTRICTED))
+        add_to_funcs( backup_file_void, MWRITEFILE,
+            backup_file_msg, IFSCHELP(nano_backup_msg), FALSE, NOVIEW);
+#endif
+
+#ifndef NANO_TINY
+    /* If we're using restricted mode, command execution is disabled.
+     * It's useless since inserting files is disabled. */
+    if (!ISSET(RESTRICTED))
+        add_to_funcs( ext_cmd_void, MINSERTFILE,
+	    ext_cmd_msg, IFSCHELP(nano_execute_msg), FALSE, NOVIEW);
+
+#ifdef ENABLE_MULTIBUFFER
+    /* If we're using restricted mode, the multibuffer toggle is
+     * disabled.  It's useless since inserting files is disabled. */
+    if (!ISSET(RESTRICTED))
+	add_to_funcs( new_buffer_void, MINSERTFILE,
+	new_buffer_msg, IFSCHELP(nano_multibuffer_msg), FALSE, NOVIEW);
+#endif
+
+    add_to_funcs( do_insertfile_void, MEXTCMD,
+	insert_file_msg, IFSCHELP(nano_insert_msg), FALSE, VIEW);
+
+#ifdef ENABLE_MULTIBUFFER
+     add_to_funcs( new_buffer_void, MEXTCMD,
+	new_buffer_msg, IFSCHELP(nano_multibuffer_msg), FALSE, NOVIEW);
+#endif
+#endif
+
+#ifndef DISABLE_HELP
+    add_to_funcs(edit_refresh, MHELP,
+	refresh_msg, nano_refresh_msg, FALSE, VIEW);
+
+    add_to_funcs(do_exit, MHELP, exit_msg, IFSCHELP(nano_exit_msg), FALSE, VIEW);
+
+
+#endif
+
+#ifndef DISABLE_BROWSER
+
+    add_to_funcs(do_first_file,
+	(MBROWSER|MWHEREISFILE),
+	first_file_msg, IFSCHELP(nano_firstfile_msg), FALSE, VIEW);
+
+    add_to_funcs(do_last_file,
+	(MBROWSER|MWHEREISFILE),
+	last_file_msg, IFSCHELP(nano_lastfile_msg), FALSE, VIEW);
+
+    add_to_funcs(goto_dir_void, MBROWSER,
+	goto_dir_msg, IFSCHELP(nano_gotodir_msg), FALSE, VIEW);
+#endif
+
+    currmenu = MMAIN;
+
+    add_to_sclist(MMAIN|MWHEREIS|MREPLACE|MREPLACE2|MGOTOLINE|MWRITEFILE|MINSERTFILE|MEXTCMD|MSPELL|MBROWSER|MWHEREISFILE|MGOTODIR,
+	"^G", do_help_void, 0, TRUE);
+    add_to_sclist(MMAIN|MWHEREIS|MREPLACE|MREPLACE2|MGOTOLINE|MWRITEFILE|MINSERTFILE|MEXTCMD|MSPELL|MBROWSER|MWHEREISFILE|MGOTODIR,
+	"F1", do_help_void, 0, TRUE);
+    add_to_sclist(MMAIN|MHELP|MBROWSER, "^X", do_exit, 0, TRUE);
+    add_to_sclist(MMAIN|MHELP|MBROWSER, "F2", do_exit, 0, TRUE);
+    add_to_sclist(MMAIN, "^_", do_gotolinecolumn_void, 0, TRUE);
+    add_to_sclist(MMAIN, "F13", do_gotolinecolumn_void, 0, TRUE);
+    add_to_sclist(MMAIN, "M-G", do_gotolinecolumn_void, 0, TRUE);
+    add_to_sclist(MMAIN, "^O", do_writeout_void, 0, TRUE);
+    add_to_sclist(MMAIN, "F3", do_writeout_void, 0, TRUE);
+#ifndef DISABLE_JUSTIFY
+    add_to_sclist(MMAIN, "^J", do_justify_void, 0, TRUE);
+    add_to_sclist(MMAIN, "F4", do_justify_void, 0, TRUE);
+#endif
+    add_to_sclist(MMAIN, "^R", do_insertfile_void, 0, TRUE);
+    add_to_sclist(MMAIN, "F5", do_insertfile_void, 0, TRUE);
+    add_to_sclist(MMAIN, "kinsert", do_insertfile_void, 0, TRUE);
+    add_to_sclist(MMAIN|MBROWSER, "^W", do_search, 0, TRUE);
+    add_to_sclist(MMAIN|MBROWSER, "F6", do_search, 0, TRUE);
+    add_to_sclist(MMAIN|MBROWSER|MHELP|MWHEREISFILE, "^Y", do_page_up, 0, TRUE);
+    add_to_sclist(MMAIN|MBROWSER|MHELP|MWHEREISFILE, "F7", do_page_up, 0, TRUE);
+    add_to_sclist(MMAIN|MBROWSER|MHELP|MWHEREISFILE, "kpup", do_page_up, 0, TRUE);
+    add_to_sclist(MMAIN|MBROWSER|MHELP|MWHEREISFILE, "^V", do_page_down, 0, TRUE);
+    add_to_sclist(MMAIN|MBROWSER|MHELP|MWHEREISFILE, "F8", do_page_down, 0, TRUE);
+    add_to_sclist(MMAIN|MBROWSER|MHELP|MWHEREISFILE, "kpdown", do_page_down, 0, TRUE);
+    add_to_sclist(MMAIN, "^K", do_cut_text_void, 0, TRUE);
+    add_to_sclist(MMAIN, "F9", do_cut_text_void, 0, TRUE);
+    add_to_sclist(MMAIN, "^U", do_uncut_text, 0, TRUE);
+    add_to_sclist(MMAIN, "F10", do_uncut_text, 0, TRUE);
+    add_to_sclist(MMAIN, "^C", do_cursorpos_void, 0, TRUE);
+    add_to_sclist(MMAIN, "F11", do_cursorpos_void, 0, TRUE);
+#ifndef DISABLE_SPELLER
+    add_to_sclist(MMAIN, "^T", do_spell, 0, TRUE);
+    add_to_sclist(MMAIN, "F12", do_spell, 0, TRUE);
+#endif
+    add_to_sclist(MMAIN, "^\\", do_replace, 0, TRUE);
+    add_to_sclist(MMAIN, "F14", do_replace, 0, TRUE);
+    add_to_sclist(MMAIN, "M-R", do_replace, 0, TRUE);
+    add_to_sclist(MWHEREIS, "^R", do_replace, 0, FALSE);
+    add_to_sclist(MREPLACE, "^R", no_replace_void, 0, FALSE);
+    add_to_sclist(MWHEREIS, "^T", do_gotolinecolumn_void, 0, FALSE);
+#ifndef NANO_TINY
+    add_to_sclist(MMAIN, "^^", do_mark, 0, TRUE);
+    add_to_sclist(MMAIN, "F15", do_mark, 0, TRUE);
+    add_to_sclist(MMAIN, "M-A", do_mark, 0, TRUE);
+    add_to_sclist(MMAIN|MBROWSER, "M-W", do_research, 0, TRUE);
+    add_to_sclist(MMAIN|MBROWSER, "F16", do_research, 0, TRUE);
+    add_to_sclist(MMAIN, "M-^", do_copy_text, 0, TRUE);
+    add_to_sclist(MMAIN, "M-6", do_copy_text, 0, TRUE);
+    add_to_sclist(MMAIN, "M-}", do_indent_void, 0, TRUE);
+    add_to_sclist(MMAIN, "M-{", do_unindent, 0, TRUE);
+    if (ISSET(UNDOABLE)) {
+	add_to_sclist(MMAIN, "M-U", do_undo, 0, TRUE);
+ 	add_to_sclist(MMAIN, "M-E", do_redo, 0, TRUE);
+    }
+    add_to_sclist(MALL, "^F", do_right, 0, TRUE);
+    add_to_sclist(MALL, "^B", do_left, 0, TRUE);
+    add_to_sclist(MMAIN, "^Space", do_next_word_void, 0, TRUE);
+    add_to_sclist(MMAIN, "M-Space", do_prev_word_void, 0, TRUE);
+#endif
+    add_to_sclist(MALL, "kright", do_right, 0, TRUE);
+    add_to_sclist(MALL, "kleft", do_left, 0, TRUE);
+    add_to_sclist(MMAIN, "^Q", xon_complaint, 0, TRUE);
+    add_to_sclist(MMAIN, "^S", xoff_complaint, 0, TRUE);
+    add_to_sclist(MMAIN|MHELP|MBROWSER, "^P", do_up_void, 0, TRUE);
+    add_to_sclist(MMAIN|MHELP|MBROWSER, "kup", do_up_void, 0, TRUE);
+    add_to_sclist(MMAIN|MHELP|MBROWSER, "^N", do_down_void, 0, TRUE);
+    add_to_sclist(MMAIN|MHELP|MBROWSER, "kdown", do_down_void, 0, TRUE);
+    add_to_sclist(MALL, "^A", do_home, 0, TRUE);
+    add_to_sclist(MALL, "khome", do_home, 0, TRUE);
+    add_to_sclist(MALL, "^E", do_end, 0, TRUE);
+    add_to_sclist(MALL, "kend", do_end, 0, TRUE);
+#ifndef NANO_TINY
+    add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2|MWHEREISFILE, "^P", get_history_older_void, 0, FALSE);
+    add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2|MWHEREISFILE, "kup", get_history_older_void, 0, FALSE);
+    add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2|MWHEREISFILE, "^N", get_history_newer_void, 0, FALSE);
+    add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2|MWHEREISFILE, "kdown", get_history_newer_void, 0, FALSE);
+#endif
+#ifndef DISABLE_JUSTIFY
+    add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2,
+	"^W", do_para_begin_void, 0, TRUE);
+    add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2,
+	"^O", do_para_end_void, 0, TRUE);
+    add_to_sclist(MALL, "M-(", do_para_begin_void, 0, TRUE);
+    add_to_sclist(MALL, "M-9", do_para_begin_void, 0, TRUE);
+    add_to_sclist(MALL, "M-)", do_para_end_void, 0, TRUE);
+    add_to_sclist(MALL, "M-0", do_para_end_void, 0, TRUE);
+#endif
+    add_to_sclist(MWHEREIS,
+	"M-C", case_sens_void, 0, FALSE);
+    add_to_sclist(MREPLACE,
+	"M-C", case_sens_void, 0, FALSE);
+    add_to_sclist(MREPLACE2,
+	"M-C", case_sens_void, 0, FALSE);
+    add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2,
+	"M-B", backwards_void, 0, FALSE);
+    add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2,
+	"M-R", regexp_void, 0, FALSE);
+
+    add_to_sclist(MMAIN, "M-\\", do_first_line, 0, TRUE);
+    add_to_sclist(MMAIN, "M-|", do_first_line, 0, TRUE);
+    add_to_sclist(MMAIN, "M-/", do_last_line, 0, TRUE);
+    add_to_sclist(MMAIN, "M-?", do_last_line, 0, TRUE);
+    add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2|MGOTOLINE|MHELP,
+	"^Y", do_first_line, 0, TRUE);
+    add_to_sclist(MWHEREIS|MREPLACE|MREPLACE2|MGOTOLINE|MHELP,
+	"^V", do_last_line, 0, TRUE);
+
+#ifndef DISABLE_BROWSER
+    add_to_sclist(MBROWSER|MWHEREISFILE, "M-\\", do_first_file, 0, TRUE);
+    add_to_sclist(MBROWSER|MWHEREISFILE, "M-|", do_first_file, 0, TRUE);
+    add_to_sclist(MBROWSER|MWHEREISFILE, "M-/", do_last_file, 0, TRUE);
+    add_to_sclist(MBROWSER|MWHEREISFILE, "M-?", do_last_file, 0, TRUE);
+#endif
+    add_to_sclist(MBROWSER|MWHEREISFILE, "^_", goto_dir_void, 0, TRUE);
+    add_to_sclist(MBROWSER|MWHEREISFILE, "F13", goto_dir_void, 0, TRUE);
+    add_to_sclist(MBROWSER|MWHEREISFILE, "M-G", goto_dir_void, 0, TRUE);
+#ifndef NANO_TINY
+    add_to_sclist(MMAIN, "M-]", do_find_bracket, 0, TRUE);
+    add_to_sclist(MMAIN, "M--", do_scroll_up, 0, TRUE);
+    add_to_sclist(MMAIN, "M-_", do_scroll_up, 0, TRUE);
+    add_to_sclist(MMAIN, "M-+", do_scroll_down, 0, TRUE);
+    add_to_sclist(MMAIN, "M-=", do_scroll_down, 0, TRUE);
+#endif
+
+#ifdef ENABLE_MULTIBUFFER
+    add_to_sclist(MMAIN, "M-<", switch_to_prev_buffer_void, 0, TRUE);
+    add_to_sclist(MMAIN, "M-,", switch_to_prev_buffer_void, 0, TRUE);
+    add_to_sclist(MMAIN, "M->", switch_to_next_buffer_void, 0, TRUE);
+    add_to_sclist(MMAIN, "M-.", switch_to_next_buffer_void, 0, TRUE);
+#endif
+    add_to_sclist(MALL, "M-V", do_verbatim_input, 0, TRUE);
+#ifndef NANO_TINY
+    add_to_sclist(MALL, "M-T", do_cut_till_end, 0, TRUE);
+#ifndef DISABLE_JUSTIFY
+    add_to_sclist(MALL, "M-J", do_full_justify, 0, TRUE);
+#endif
+    add_to_sclist(MMAIN, "M-D", do_wordlinechar_count, 0, TRUE);
+    add_to_sclist(MMAIN, "M-X", do_toggle_void, NO_HELP, TRUE);
+    add_to_sclist(MMAIN, "M-C", do_toggle_void, CONST_UPDATE, TRUE);
+    add_to_sclist(MMAIN, "M-O", do_toggle_void, MORE_SPACE, TRUE);
+    add_to_sclist(MMAIN, "M-S", do_toggle_void, SMOOTH_SCROLL, TRUE);
+    add_to_sclist(MMAIN, "M-P", do_toggle_void, WHITESPACE_DISPLAY, TRUE);
+    add_to_sclist(MMAIN, "M-Y", do_toggle_void, NO_COLOR_SYNTAX, TRUE);
+    add_to_sclist(MMAIN, "M-H", do_toggle_void, SMART_HOME, TRUE);
+    add_to_sclist(MMAIN, "M-I", do_toggle_void, AUTOINDENT, TRUE);
+    add_to_sclist(MMAIN, "M-K", do_toggle_void, CUT_TO_END, TRUE);
+    add_to_sclist(MMAIN, "M-L", do_toggle_void, NO_WRAP, TRUE);
+    add_to_sclist(MMAIN, "M-Q", do_toggle_void, TABS_TO_SPACES, TRUE);
+    add_to_sclist(MMAIN, "M-B", do_toggle_void, BACKUP_FILE, TRUE);
+    add_to_sclist(MMAIN, "M-F", do_toggle_void, MULTIBUFFER, TRUE);
+    add_to_sclist(MMAIN, "M-M", do_toggle_void, USE_MOUSE, TRUE);
+    add_to_sclist(MMAIN, "M-N", do_toggle_void, NO_CONVERT, TRUE);
+    add_to_sclist(MMAIN, "M-Z", do_toggle_void, SUSPEND, TRUE);
+    add_to_sclist(MMAIN, "M-$", do_toggle_void, SOFTWRAP, TRUE);
+#endif
+    add_to_sclist(MGOTOLINE, "^T",  gototext_void, 0, FALSE);
+    add_to_sclist(MINSERTFILE|MEXTCMD, "M-F",  new_buffer_void, 0, FALSE);
+    add_to_sclist((MWHEREIS|MREPLACE|MREPLACE2|MGOTOLINE|MWRITEFILE|MINSERTFILE|MEXTCMD|MSPELL|MWHEREISFILE|MGOTODIR|MYESNO),
+	"^C", do_cancel, 0, FALSE);
+    add_to_sclist(MHELP, "^X", do_exit, 0, TRUE);
+    add_to_sclist(MHELP, "F2", do_exit, 0, TRUE);
+    add_to_sclist(MWRITEFILE, "M-D",  dos_format_void, 0, FALSE);
+    add_to_sclist(MWRITEFILE, "M-M",  mac_format_void, 0, FALSE);
+    add_to_sclist(MWRITEFILE, "M-A",  append_void, 0, FALSE);
+    add_to_sclist(MWRITEFILE, "M-P",  prepend_void, 0, FALSE);
+    add_to_sclist(MWRITEFILE, "M-B",  backup_file_void, 0, FALSE);
+    add_to_sclist(MWRITEFILE, "^T",   to_files_void, 0, FALSE);
+    add_to_sclist(MINSERTFILE, "^T",  to_files_void, 0, FALSE);
+    add_to_sclist(MINSERTFILE, "^X",  ext_cmd_void, 0, FALSE);
+    add_to_sclist(MMAIN, "^Z", do_suspend_void, 0, FALSE);
+    add_to_sclist(MMAIN, "^L", total_refresh, 0, TRUE);
+    add_to_sclist(MALL, "^I", do_tab, 0, TRUE);
+    add_to_sclist(MALL, "^M", do_enter_void, 0, TRUE);
+    add_to_sclist(MALL, "kenter", do_enter_void, 0, TRUE);
+    add_to_sclist(MALL, "^D", do_delete, 0, TRUE);
+    add_to_sclist(MALL, "kdel", do_delete, 0, TRUE);
+    add_to_sclist(MALL, "^H", do_backspace, 0, TRUE);
+    add_to_sclist(MALL, "kbsp", do_backspace, 0, TRUE);
+
+#ifdef DEBUG
+    print_sclist();
+#endif
+
+}
+
+/* Free the given shortcut. */
+void free_shortcutage(shortcut **shortcutage)
+{
+    assert(shortcutage != NULL);
+
+    while (*shortcutage != NULL) {
+	shortcut *ps = *shortcutage;
+	*shortcutage = (*shortcutage)->next;
+	free(ps);
+    }
+}
+
+const subnfunc *sctofunc(sc *s)
+{
+    subnfunc *f;
+
+    for (f = allfuncs; f != NULL && s->scfunc != f->scfunc; f = f->next)
+	;
+
+    return f;
+}
+
+#ifndef NANO_TINY
+/* Now lets come up with a single (hopefully)
+   function to get a string for each flag */
+const char *flagtostr(int flag)
+{
+   switch (flag) {
+        case NO_HELP:
+            return N_("Help mode");
+        case CONST_UPDATE:
+            return N_("Constant cursor position display");
+        case MORE_SPACE:
+            return N_("Use of one more line for editing");
+        case SMOOTH_SCROLL:
+            return N_("Smooth scrolling");
+        case WHITESPACE_DISPLAY:
+            return N_("Whitespace display");
+        case NO_COLOR_SYNTAX:
+            return N_("Color syntax highlighting");
+        case SMART_HOME:
+            return N_("Smart home key");
+        case AUTOINDENT:
+            return N_("Auto indent");
+        case CUT_TO_END:
+            return N_("Cut to end");
+        case NO_WRAP:
+            return N_("Long line wrapping");
+        case TABS_TO_SPACES:
+            return N_("Conversion of typed tabs to spaces");
+        case BACKUP_FILE:
+            return N_("Backup files");
+        case MULTIBUFFER:
+            return N_("Multiple file buffers");
+        case USE_MOUSE:
+            return N_("Mouse support");
+        case NO_CONVERT:
+            return N_("No conversion from DOS/Mac format");
+        case SUSPEND:
+            return N_("Suspension");
+        case SOFTWRAP:
+            return N_("Soft line wrapping");
+        default:
+            return "?????";
+    }
+}
+#endif /* NANO_TINY */
+
+/* Interpret the string given by the rc file and return a
+    shortcut struct, complete with proper value for execute */
+sc *strtosc(int menu, char *input)
+{
+     sc *s;
+
+    s = (sc *)nmalloc(sizeof(sc));
+    s->execute = TRUE; /* overridden as needed below */
+
+
+#ifndef DISABLE_HELP
+    if (!strcasecmp(input, "help"))
+	s->scfunc = do_help_void;
+    else
+#endif
+    if (!strcasecmp(input, "cancel")) {
+	s->scfunc = do_cancel;
+	s->execute = FALSE;
+    } else if (!strcasecmp(input, "exit"))
+	s->scfunc = do_exit;
+    else if (!strcasecmp(input, "writeout"))
+	s->scfunc = do_writeout_void;
+    else if (!strcasecmp(input, "insert"))
+	s->scfunc = do_insertfile_void;
+    else if (!strcasecmp(input, "whereis"))
+	s->scfunc = do_search;
+    else if (!strcasecmp(input, "up"))
+	s->scfunc = do_up_void;
+    else if (!strcasecmp(input, "down"))
+	s->scfunc = do_down_void;
+    else if (!strcasecmp(input, "pageup")
+	|| !strcasecmp(input, "prevpage"))
+	s->scfunc = do_page_up;
+    else if (!strcasecmp(input, "pagedown")
+	|| !strcasecmp(input, "nextpage"))
+	s->scfunc = do_page_down;
+    else if (!strcasecmp(input, "cut"))
+	s->scfunc = do_cut_text_void;
+    else if (!strcasecmp(input, "uncut"))
+	s->scfunc = do_uncut_text;
+    else if (!strcasecmp(input, "curpos") ||
+	!strcasecmp(input, "cursorpos"))
+	s->scfunc = do_cursorpos_void;
+    else if (!strcasecmp(input, "firstline"))
+	s->scfunc = do_first_line;
+    else if (!strcasecmp(input, "lastline"))
+	s->scfunc = do_last_line;
+    else if (!strcasecmp(input, "gotoline"))
+	s->scfunc = do_gotolinecolumn_void;
+    else if (!strcasecmp(input, "replace"))
+	s->scfunc = do_replace;
+#ifndef DISABLE_JUSTIFY
+    else if (!strcasecmp(input, "justify"))
+	s->scfunc = do_justify_void;
+    else if (!strcasecmp(input, "beginpara"))
+	s->scfunc = do_para_begin_void;
+    else if (!strcasecmp(input, "endpara"))
+	s->scfunc = do_para_end_void;
+    else if (!strcasecmp(input, "fulljustify"))
+	s->scfunc = do_full_justify;
+#endif
+#ifndef NANO_TINY
+    else if (!strcasecmp(input, "mark"))
+	s->scfunc = do_mark;
+    else if (!strcasecmp(input, "searchagain") ||
+		!strcasecmp(input, "research"))
+	s->scfunc = do_research;
+    else if (!strcasecmp(input, "copytext"))
+	s->scfunc = do_copy_text;
+    else if (!strcasecmp(input, "indent"))
+	s->scfunc = do_indent_void;
+    else if (!strcasecmp(input, "unindent"))
+	s->scfunc = do_unindent;
+    else if (!strcasecmp(input, "scrollup"))
+	s->scfunc = do_scroll_up;
+    else if (!strcasecmp(input, "scrolldown"))
+	s->scfunc = do_scroll_down;
+    else if (!strcasecmp(input, "nextword"))
+	s->scfunc = do_next_word_void;
+    else if (!strcasecmp(input, "suspend"))
+	s->scfunc = do_suspend_void;
+    else if (!strcasecmp(input, "prevword"))
+	s->scfunc = do_prev_word_void;
+    else if (!strcasecmp(input, "findbracket"))
+	s->scfunc = do_find_bracket;
+    else if (!strcasecmp(input, "wordcount"))
+	s->scfunc = do_wordlinechar_count;
+    else if (!strcasecmp(input, "undo"))
+	s->scfunc = do_undo;
+    else if (!strcasecmp(input, "redo"))
+	s->scfunc = do_redo;
+    else if (!strcasecmp(input, "prevhistory")) {
+	s->scfunc =  get_history_older_void;
+	s->execute = FALSE;
+    } else if (!strcasecmp(input, "nexthistory")) {
+	s->scfunc =  get_history_newer_void;
+	s->execute = FALSE;
+    } else if (!strcasecmp(input, "nohelp") ||
+		!strcasecmp(input, "nohelp")) {
+	s->scfunc =  do_toggle_void;
+	s->execute = FALSE;
+	s->toggle = NO_HELP;
+    } else if (!strcasecmp(input, "constupdate")) {
+	s->scfunc =  do_toggle_void;
+	s->execute = FALSE;
+	s->toggle = CONST_UPDATE;
+    } else if (!strcasecmp(input, "morespace")) {
+	s->scfunc =  do_toggle_void;
+	s->execute = FALSE;
+	s->toggle = MORE_SPACE;
+    } else if (!strcasecmp(input, "smoothscroll")) {
+	s->scfunc =  do_toggle_void;
+	s->execute = FALSE;
+	s->toggle = SMOOTH_SCROLL;
+    } else if (!strcasecmp(input, "whitespacedisplay")) {
+	s->scfunc =  do_toggle_void;
+	s->execute = FALSE;
+	s->toggle = WHITESPACE_DISPLAY;
+    } else if (!strcasecmp(input, "nosyntax")) {
+	s->scfunc =  do_toggle_void;
+	s->execute = FALSE;
+	s->toggle = NO_COLOR_SYNTAX;
+    } else if (!strcasecmp(input, "smarthome")) {
+	s->scfunc =  do_toggle_void;
+	s->execute = FALSE;
+	s->toggle = SMART_HOME;
+    } else if (!strcasecmp(input, "autoindent")) {
+	s->scfunc =  do_toggle_void;
+	s->execute = FALSE;
+	s->toggle = AUTOINDENT;
+    } else if (!strcasecmp(input, "cuttoend")) {
+	s->scfunc =  do_toggle_void;
+	s->execute = FALSE;
+	s->toggle = CUT_TO_END;
+    } else if (!strcasecmp(input, "nowrap")) {
+	s->scfunc =  do_toggle_void;
+	s->execute = FALSE;
+	s->toggle = NO_WRAP;
+    } else if (!strcasecmp(input, "tabstospaces")) {
+	s->scfunc =  do_toggle_void;
+	s->execute = FALSE;
+	s->toggle = TABS_TO_SPACES;
+    } else if (!strcasecmp(input, "backupfile")) {
+	s->scfunc =  do_toggle_void;
+	s->execute = FALSE;
+	s->toggle = BACKUP_FILE;
+    } else if (!strcasecmp(input, "mutlibuffer")) {
+	s->scfunc =  do_toggle_void;
+	s->execute = FALSE;
+	s->toggle = MULTIBUFFER;
+    } else if (!strcasecmp(input, "mouse")) {
+	s->scfunc =  do_toggle_void;
+	s->execute = FALSE;
+	s->toggle = USE_MOUSE;
+    } else if (!strcasecmp(input, "noconvert")) {
+	s->scfunc =  do_toggle_void;
+	s->execute = FALSE;
+	s->toggle = NO_CONVERT;
+    } else if (!strcasecmp(input, "suspendenable")) {
+	s->scfunc =  do_toggle_void;
+	s->execute = FALSE;
+	s->toggle = SUSPEND;
+    }
+#endif /* NANO_TINY */
+    else if (!strcasecmp(input, "right") ||
+		!strcasecmp(input, "forward"))
+	s->scfunc = do_right;
+    else if (!strcasecmp(input, "left") ||
+		!strcasecmp(input, "back"))
+	s->scfunc = do_left;
+    else if (!strcasecmp(input, "up") ||
+		!strcasecmp(input, "prevline"))
+	s->scfunc = do_up_void;
+    else if (!strcasecmp(input, "down") ||
+		!strcasecmp(input, "nextline"))
+	s->scfunc = do_down_void;
+    else if (!strcasecmp(input, "home"))
+	s->scfunc = do_home;
+    else if (!strcasecmp(input, "end"))
+	s->scfunc = do_end;
+#ifdef ENABLE_MULTIBUFFER
+    else if (!strcasecmp(input, "prevbuf"))
+	s->scfunc = switch_to_prev_buffer_void;
+    else if (!strcasecmp(input, "nextbuf"))
+	s->scfunc = switch_to_next_buffer_void;
+#endif
+    else if (!strcasecmp(input, "verbatim"))
+	s->scfunc = do_verbatim_input;
+    else if (!strcasecmp(input, "tab"))
+	s->scfunc = do_tab;
+    else if (!strcasecmp(input, "enter"))
+	s->scfunc = do_enter_void;
+    else if (!strcasecmp(input, "delete"))
+	s->scfunc = do_delete;
+    else if (!strcasecmp(input, "backspace"))
+	s->scfunc = do_backspace;
+    else if (!strcasecmp(input, "refresh"))
+	s->scfunc = total_refresh;
+    else if (!strcasecmp(input, "casesens")) {
+	s->scfunc = case_sens_void;
+	s->execute = FALSE;
+    } else if (!strcasecmp(input, "regexp") ||
+		!strcasecmp(input, "regex")) {
+	s->scfunc = regexp_void;
+	s->execute = FALSE;
+    } else if (!strcasecmp(input, "dontreplace")) {
+	s->scfunc = no_replace_void;
+	s->execute = FALSE;
+    } else if (!strcasecmp(input, "gototext")) {
+	s->scfunc = gototext_void;
+	s->execute = FALSE;
+    } else if (!strcasecmp(input, "browser") ||
+		!strcasecmp(input, "tofiles")) {
+	s->scfunc = to_files_void;
+	s->execute = FALSE;
+    } else if (!strcasecmp(input, "dosformat")) {
+	s->scfunc = dos_format_void;
+	s->execute = FALSE;
+    } else if (!strcasecmp(input, "macformat")) {
+	s->scfunc =  mac_format_void;
+	s->execute = FALSE;
+    } else if (!strcasecmp(input, "append")) {
+	s->scfunc =  append_void;
+	s->execute = FALSE;
+    } else if (!strcasecmp(input, "prepend")) {
+	s->scfunc =  prepend_void;
+	s->execute = FALSE;
+    } else if (!strcasecmp(input, "backup")) {
+	s->scfunc =  backup_file_void;
+	s->execute = FALSE;
+#ifdef ENABLE_MULTIBUFFER
+    } else if (!strcasecmp(input, "newbuffer")) {
+	s->scfunc =  new_buffer_void;
+	s->execute = FALSE;
+#endif
+#ifndef DISABLE_BROWSER
+    } else if (!strcasecmp(input, "firstfile")) {
+	s->scfunc =  do_first_file;
+	s->execute = FALSE;
+    } else if (!strcasecmp(input, "lastfile")) {
+	s->scfunc = do_last_file;
+	s->execute = FALSE;
+#endif
+    } else {
+	free(s);
+	return NULL;
+    }
+
+    return s;
+
+}
+
+#ifdef ENABLE_NANORC
+/* Same thing as abnove but for the menu */
+int strtomenu(char *input)
+{
+    if (!strcasecmp(input, "all"))
+	return MALL;
+    else if (!strcasecmp(input, "main"))
+	return MMAIN;
+    else if (!strcasecmp(input, "search"))
+	return MWHEREIS;
+    else if (!strcasecmp(input, "replace"))
+	return MREPLACE;
+    else if (!strcasecmp(input, "replace2") ||
+		!strcasecmp(input, "replacewith"))
+	return MREPLACE2;
+    else if (!strcasecmp(input, "gotoline"))
+	return MGOTOLINE;
+    else if (!strcasecmp(input, "writeout"))
+	return MWRITEFILE;
+    else if (!strcasecmp(input, "insert"))
+	return MINSERTFILE;
+    else if (!strcasecmp(input, "externalcmd") ||
+		!strcasecmp(input, "extcmd"))
+	return MEXTCMD;
+    else if (!strcasecmp(input, "help"))
+	return MHELP;
+    else if (!strcasecmp(input, "spell"))
+	return MSPELL;
+    else if (!strcasecmp(input, "browser"))
+	return MBROWSER;
+    else if (!strcasecmp(input, "whereisfile"))
+	return MWHEREISFILE;
+    else if (!strcasecmp(input, "gotodir"))
+	return MGOTODIR;
+
+    return -1;
+}
+#endif
+
+
+#ifdef DEBUG
+/* This function is used to gracefully return all the memory we've used.
+ * It should be called just before calling exit().  Practically, the
+ * only effect is to cause a segmentation fault if the various data
+ * structures got bolloxed earlier.  Thus, we don't bother having this
+ * function unless debugging is turned on. */
+void thanks_for_all_the_fish(void)
+{
+    delwin(topwin);
+    delwin(edit);
+    delwin(bottomwin);
+
+#ifndef DISABLE_JUSTIFY
+    if (quotestr != NULL)
+	free(quotestr);
+#ifdef HAVE_REGEX_H
+    regfree(&quotereg);
+    if (quoteerr != NULL)
+	free(quoteerr);
+#endif
+#endif
+#ifndef NANO_TINY
+    if (backup_dir != NULL)
+        free(backup_dir);
+#endif
+#ifndef DISABLE_OPERATINGDIR
+    if (operating_dir != NULL)
+	free(operating_dir);
+    if (full_operating_dir != NULL)
+	free(full_operating_dir);
+#endif
+    if (last_search != NULL)
+	free(last_search);
+    if (last_replace != NULL)
+	free(last_replace);
+#ifndef DISABLE_SPELLER
+    if (alt_speller != NULL)
+	free(alt_speller);
+#endif
+    if (answer != NULL)
+	free(answer);
+    if (cutbuffer != NULL)
+	free_filestruct(cutbuffer);
+#ifndef DISABLE_JUSTIFY
+    if (jusbuffer != NULL)
+	free_filestruct(jusbuffer);
+#endif
+#ifdef DEBUG
+    /* Free the memory associated with each open file buffer. */
+    if (openfile != NULL)
+	free_openfilestruct(openfile);
+#endif
+#ifdef ENABLE_COLOR
+    if (syntaxstr != NULL)
+	free(syntaxstr);
+    while (syntaxes != NULL) {
+	syntaxtype *bill = syntaxes;
+
+	free(syntaxes->desc);
+	while (syntaxes->extensions != NULL) {
+	    exttype *bob = syntaxes->extensions;
+
+	    syntaxes->extensions = bob->next;
+	    free(bob->ext_regex);
+	    if (bob->ext != NULL) {
+		regfree(bob->ext);
+		free(bob->ext);
+	    }
+	    free(bob);
+	}
+	while (syntaxes->color != NULL) {
+	    colortype *bob = syntaxes->color;
+
+	    syntaxes->color = bob->next;
+	    free(bob->start_regex);
+	    if (bob->start != NULL) {
+		regfree(bob->start);
+		free(bob->start);
+	    }
+	    if (bob->end_regex != NULL)
+		free(bob->end_regex);
+	    if (bob->end != NULL) {
+		regfree(bob->end);
+		free(bob->end);
+	    }
+	    free(bob);
+	}
+	syntaxes = syntaxes->next;
+	free(bill);
+    }
+#endif /* ENABLE_COLOR */
+#ifndef NANO_TINY
+    /* Free the search and replace history lists. */
+    if (searchage != NULL)
+	free_filestruct(searchage);
+    if (replaceage != NULL)
+	free_filestruct(replaceage);
+#endif
+#ifdef ENABLE_NANORC
+    if (homedir != NULL)
+	free(homedir);
+#endif
+}
+
+#endif /* DEBUG */
+
diff --git a/src/help.c b/src/help.c
new file mode 100644
index 0000000..6eee129
--- /dev/null
+++ b/src/help.c
@@ -0,0 +1,563 @@
+/* $Id: help.c 4535 2011-02-26 14:22:37Z astyanax $ */
+/**************************************************************************
+ *   help.c                                                               *
+ *                                                                        *
+ *   Copyright (C) 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 <string.h>
+#include <ctype.h>
+
+#ifndef DISABLE_HELP
+
+static char *help_text = NULL;
+	/* The text displayed in the help window. */
+
+/* Our main help browser function.  refresh_func is the function we will
+ * call to refresh the edit window. */
+void do_help(void (*refresh_func)(void))
+{
+    int kbinput = ERR;
+    bool meta_key, func_key, old_no_help = ISSET(NO_HELP);
+    bool abort = FALSE;
+	/* Whether we should abort the help browser. */
+    size_t line = 0;
+	/* The line number in help_text of the first displayed help
+	 * line.  This variable is zero-based. */
+    size_t last_line = 0;
+	/* The line number in help_text of the last help line.  This
+	 * variable is zero-based. */
+#ifndef DISABLE_MOUSE
+	/* The current shortcut list. */
+    int oldmenu = currmenu;
+#endif
+    const char *ptr;
+	/* The current line of the help text. */
+    size_t old_line = (size_t)-1;
+	/* The line we were on before the current line. */
+    const sc *s;
+    const subnfunc *f;
+
+    curs_set(0);
+    blank_edit();
+    wattroff(bottomwin, reverse_attr);
+    blank_statusbar();
+
+    /* Set help_text as the string to display. */
+    help_init();
+
+    assert(help_text != NULL);
+
+#ifndef DISABLE_MOUSE
+    /* Set currmenu to allow clicking on the help screen's shortcut
+     * list, after help_init() is called. */
+    currmenu = MHELP;
+#endif
+
+    if (ISSET(NO_HELP)) {
+	/* Make sure that the help screen's shortcut list will actually
+	 * be displayed. */
+	UNSET(NO_HELP);
+	window_init();
+    }
+
+    bottombars(MHELP);
+    wnoutrefresh(bottomwin);
+
+    /* Get the last line of the help text. */
+    ptr = help_text;
+
+    for (; *ptr != '\0'; last_line++) {
+	ptr += help_line_len(ptr);
+	if (*ptr == '\n')
+	    ptr++;
+    }
+    if (last_line > 0)
+	last_line--;
+
+    while (!abort) {
+	size_t i;
+
+	/* Display the help text if we don't have a key, or if the help
+	 * text has moved. */
+	if (kbinput == ERR || line != old_line) {
+	    blank_edit();
+
+	    ptr = help_text;
+
+	    /* Calculate where in the text we should be, based on the
+	     * page. */
+	    for (i = 0; i < line; i++) {
+		ptr += help_line_len(ptr);
+		if (*ptr == '\n')
+		    ptr++;
+	    }
+
+	    for (i = 0; i < editwinrows && *ptr != '\0'; i++) {
+		size_t j = help_line_len(ptr);
+
+		mvwaddnstr(edit, i, 0, ptr, j);
+		ptr += j;
+		if (*ptr == '\n')
+		    ptr++;
+	    }
+	}
+
+	wnoutrefresh(edit);
+
+	old_line = line;
+
+	kbinput = get_kbinput(edit, &meta_key, &func_key);
+
+#ifndef DISABLE_MOUSE
+        if (kbinput == KEY_MOUSE) {
+		int mouse_x, mouse_y;
+		get_mouseinput(&mouse_x, &mouse_y, TRUE);
+		continue;
+	    /* Redraw the screen. */
+	}
+#endif
+
+	parse_help_input(&kbinput, &meta_key, &func_key);
+        s = get_shortcut(MHELP, &kbinput, &meta_key, &func_key);
+	if (!s)
+	    continue;
+        f = sctofunc((sc *) s);
+	if (!f)
+	    continue;
+
+	  if (f->scfunc == total_refresh) {
+		total_redraw();
+		break;
+	} else if (f->scfunc == do_page_up) {
+		if (line > editwinrows - 2)
+		    line -= editwinrows - 2;
+		else
+		    line = 0;
+	} else if (f->scfunc == do_page_down) {
+		if (line + (editwinrows - 1) < last_line)
+		    line += editwinrows - 2;
+	} else if (f->scfunc == do_up_void) {
+		if (line > 0)
+		    line--;
+	} else if (f->scfunc == do_down_void) {
+		if (line + (editwinrows - 1) < last_line)
+		    line++;
+	} else if (f->scfunc == do_first_line) {
+		if (meta_key)
+		    line = 0;
+		break;
+	} else if (f->scfunc == do_last_line) {
+		if (meta_key) {
+		    if (line + (editwinrows - 1) < last_line)
+			line = last_line - (editwinrows - 1);
+		}
+		break;
+	    /* Abort the help browser. */
+	} else if (f->scfunc == do_exit) {
+		abort = TRUE;
+		break;
+	}
+    }
+
+#ifndef DISABLE_MOUSE
+    currmenu = oldmenu;
+#endif
+
+    if (old_no_help) {
+	blank_bottombars();
+	wnoutrefresh(bottomwin);
+	SET(NO_HELP);
+	window_init();
+    } else
+	bottombars(currmenu);
+
+    curs_set(1);
+    refresh_func();
+
+    /* The help_init() at the beginning allocated help_text.  Since
+     * help_text has now been written to the screen, we don't need it
+     * anymore. */
+    free(help_text);
+    help_text = NULL;
+}
+
+#ifndef DISABLE_BROWSER
+/* Start the help browser for the file browser. */
+void do_browser_help(void)
+{
+    do_help(&browser_refresh);
+}
+#endif
+
+/* This function allocates help_text, and stores the help string in it.
+ * help_text should be NULL initially. */
+void help_init(void)
+{
+    size_t allocsize = 0;	/* Space needed for help_text. */
+    const char *htx[3];		/* Untranslated help message.  We break
+				 * it up into three chunks in case the
+				 * full string is too long for the
+				 * compiler to handle. */
+    char *ptr;
+    const subnfunc *f;
+    const sc *s;
+    int scsfound = 0;
+
+#ifndef NANO_TINY
+#ifdef ENABLE_NANORC
+    bool old_whitespace = ISSET(WHITESPACE_DISPLAY);
+
+    UNSET(WHITESPACE_DISPLAY);
+#endif
+#endif
+
+    /* First, set up the initial help text for the current function. */
+    if (currmenu == MWHEREIS || currmenu == MREPLACE || currmenu == MREPLACE2) {
+	htx[0] = N_("Search Command Help Text\n\n "
+		"Enter the words or characters you would like to "
+		"search for, and then press Enter.  If there is a "
+		"match for the text you entered, the screen will be "
+		"updated to the location of the nearest match for the "
+		"search string.\n\n The previous search string will be "
+		"shown in brackets after the search prompt.  Hitting "
+		"Enter without entering any text will perform the "
+		"previous search.  ");
+	htx[1] = N_("If you have selected text with the mark and then "
+		"search to replace, only matches in the selected text "
+		"will be replaced.\n\n The following function keys are "
+		"available in Search mode:\n\n");
+	htx[2] = NULL;
+    } else if (currmenu == MGOTOLINE) {
+	htx[0] = N_("Go To Line Help Text\n\n "
+		"Enter the line number that you wish to go to and hit "
+		"Enter.  If there are fewer lines of text than the "
+		"number you entered, you will be brought to the last "
+		"line of the file.\n\n The following function keys are "
+		"available in Go To Line mode:\n\n");
+	htx[1] = NULL;
+	htx[2] = NULL;
+    } else if (currmenu == MINSERTFILE) {
+	htx[0] = N_("Insert File Help Text\n\n "
+		"Type in the name of a file to be inserted into the "
+		"current file buffer at the current cursor "
+		"location.\n\n If you have compiled nano with multiple "
+		"file buffer support, and enable multiple file buffers "
+		"with the -F or --multibuffer command line flags, the "
+		"Meta-F toggle, or a nanorc file, inserting a file "
+		"will cause it to be loaded into a separate buffer "
+		"(use Meta-< and > to switch between file buffers).  ");
+	htx[1] = N_("If you need another blank buffer, do not enter "
+		"any filename, or type in a nonexistent filename at "
+		"the prompt and press Enter.\n\n The following "
+		"function keys are available in Insert File mode:\n\n");
+	htx[2] = NULL;
+    } else if (currmenu == MWRITEFILE) {
+	htx[0] = N_("Write File Help Text\n\n "
+		"Type the name that you wish to save the current file "
+		"as and press Enter to save the file.\n\n If you have "
+		"selected text with the mark, you will be prompted to "
+		"save only the selected portion to a separate file.  To "
+		"reduce the chance of overwriting the current file with "
+		"just a portion of it, the current filename is not the "
+		"default in this mode.\n\n The following function keys "
+		"are available in Write File mode:\n\n");
+	htx[1] = NULL;
+	htx[2] = NULL;
+    }
+#ifndef DISABLE_BROWSER
+    else if (currmenu == MBROWSER) {
+	htx[0] = N_("File Browser Help Text\n\n "
+		"The file browser is used to visually browse the "
+		"directory structure to select a file for reading "
+		"or writing.  You may use the arrow keys or Page Up/"
+		"Down to browse through the files, and S or Enter to "
+		"choose the selected file or enter the selected "
+		"directory.  To move up one level, select the "
+		"directory called \"..\" at the top of the file "
+		"list.\n\n The following function keys are available "
+		"in the file browser:\n\n");
+	htx[1] = NULL;
+	htx[2] = NULL;
+    } else if (currmenu == MWHEREISFILE) {
+	htx[0] = N_("Browser Search Command Help Text\n\n "
+		"Enter the words or characters you would like to "
+		"search for, and then press Enter.  If there is a "
+		"match for the text you entered, the screen will be "
+		"updated to the location of the nearest match for the "
+		"search string.\n\n The previous search string will be "
+		"shown in brackets after the search prompt.  Hitting "
+		"Enter without entering any text will perform the "
+		"previous search.\n\n");
+	htx[1] = N_(" The following function keys are available in "
+		"Browser Search mode:\n\n");
+	htx[2] = NULL;
+    } else if (currmenu == MGOTODIR) {
+	htx[0] = N_("Browser Go To Directory Help Text\n\n "
+		"Enter the name of the directory you would like to "
+		"browse to.\n\n If tab completion has not been "
+		"disabled, you can use the Tab key to (attempt to) "
+		"automatically complete the directory name.\n\n The "
+		"following function keys are available in Browser Go "
+		"To Directory mode:\n\n");
+	htx[1] = NULL;
+	htx[2] = NULL;
+    }
+#endif /* !DISABLE_BROWSER */
+#ifndef DISABLE_SPELLER
+    else if (currmenu == MSPELL) {
+	htx[0] = N_("Spell Check Help Text\n\n "
+		"The spell checker checks the spelling of all text in "
+		"the current file.  When an unknown word is "
+		"encountered, it is highlighted and a replacement can "
+		"be edited.  It will then prompt to replace every "
+		"instance of the given misspelled word in the current "
+		"file, or, if you have selected text with the mark, in "
+		"the selected text.\n\n The following function keys "
+		"are available in Spell Check mode:\n\n");
+	htx[1] = NULL;
+	htx[2] = NULL;
+    }
+#endif /* !DISABLE_SPELLER */
+#ifndef NANO_TINY
+    else if (currmenu == MEXTCMD) {
+	htx[0] = N_("Execute Command Help Text\n\n "
+		"This mode allows you to insert the output of a "
+		"command run by the shell into the current buffer (or "
+		"a new buffer in multiple file buffer mode).  If you "
+		"need another blank buffer, do not enter any "
+		"command.\n\n The following function keys are "
+		"available in Execute Command mode:\n\n");
+	htx[1] = NULL;
+	htx[2] = NULL;
+    }
+#endif /* !NANO_TINY */
+    else {
+	/* Default to the main help list. */
+	htx[0] = N_("Main nano help text\n\n "
+		"The nano editor is designed to emulate the "
+		"functionality and ease-of-use of the UW Pico text "
+		"editor.  There are four main sections of the editor.  "
+		"The top line shows the program version, the current "
+		"filename being edited, and whether or not the file "
+		"has been modified.  Next is the main editor window "
+		"showing the file being edited.  The status line is "
+		"the third line from the bottom and shows important "
+		"messages.  ");
+	htx[1] = N_("The bottom two lines show the most commonly used "
+		"shortcuts in the editor.\n\n The notation for "
+		"shortcuts is as follows: Control-key sequences are "
+		"notated with a caret (^) symbol and can be entered "
+		"either by using the Control (Ctrl) key or pressing "
+		"the Escape (Esc) key twice.  Escape-key sequences are "
+		"notated with the Meta (M-) symbol and can be entered "
+		"using either the Esc, Alt, or Meta key depending on "
+		"your keyboard setup.  ");
+	htx[2] = N_("Also, pressing Esc twice and then typing a "
+		"three-digit decimal number from 000 to 255 will enter "
+		"the character with the corresponding value.  The "
+		"following keystrokes are available in the main editor "
+		"window.  Alternative keys are shown in "
+		"parentheses:\n\n");
+    }
+
+    htx[0] = _(htx[0]);
+    if (htx[1] != NULL)
+	htx[1] = _(htx[1]);
+    if (htx[2] != NULL)
+	htx[2] = _(htx[2]);
+
+    allocsize += strlen(htx[0]);
+    if (htx[1] != NULL)
+	allocsize += strlen(htx[1]);
+    if (htx[2] != NULL)
+	allocsize += strlen(htx[2]);
+
+    /* Count the shortcut help text.  Each entry has up to three keys,
+     * which fill 24 columns, plus translated text, plus one or two
+     * \n's. */
+	for (f = allfuncs; f != NULL; f = f->next)
+            if (f->menus & currmenu)
+		allocsize += (24 * mb_cur_max()) + strlen(f->help) + 2;
+
+#ifndef NANO_TINY
+    /* If we're on the main list, we also count the toggle help text.
+     * Each entry has "M-%c\t\t\t", which fills 24 columns, plus a
+     * space, plus translated text, plus one or two '\n's. */
+    if (currmenu == MMAIN) {
+	size_t endis_len = strlen(_("enable/disable"));
+
+	for (s = sclist; s != NULL; s = s->next)
+            if (s->scfunc ==  do_toggle_void)
+		allocsize += strlen(_(flagtostr(s->toggle))) + endis_len + 9;
+
+    }
+#endif
+
+    /* help_text has been freed and set to NULL unless the user resized
+     * while in the help screen. */
+    if (help_text != NULL)
+	free(help_text);
+
+    /* Allocate space for the help text. */
+    help_text = charalloc(allocsize + 1);
+
+    /* Now add the text we want. */
+    strcpy(help_text, htx[0]);
+    if (htx[1] != NULL)
+	strcat(help_text, htx[1]);
+    if (htx[2] != NULL)
+	strcat(help_text, htx[2]);
+
+    ptr = help_text + strlen(help_text);
+
+    /* Now add our shortcut info. */
+    for (f = allfuncs; f != NULL; f = f->next) {
+
+        if ((f->menus & currmenu) == 0)
+	    continue;
+
+        if (!f->desc || !strcmp(f->desc, ""))
+	    continue;
+
+        /* Lets just try and use the first 3 shortcuts
+           from the new struct... */
+        for (s = sclist, scsfound = 0; s != NULL; s = s->next) {
+
+            if (scsfound == 3)
+		continue;
+
+            if (s->type == RAWINPUT)
+		continue;
+
+	    if ((s->menu & currmenu) == 0)
+		continue;
+
+            if (s->scfunc == f->scfunc) {
+		scsfound++;
+
+		if (scsfound == 1)
+		    ptr += sprintf(ptr, "%s", s->keystr);
+		else
+		    ptr += sprintf(ptr, "(%s)", s->keystr);
+		*(ptr++) = '\t';
+	    }
+	}
+	/* Pad with tabs if we didnt find 3 */
+        for (; scsfound < 3; scsfound++) {
+	    *(ptr++) = '\t';
+	}
+
+	/* The shortcut's help text. */
+	ptr += sprintf(ptr, "%s\n", _(f->help));
+
+	if (f->blank_after)
+	    ptr += sprintf(ptr, "\n");
+    }
+
+#ifndef NANO_TINY
+    /* And the toggles... */
+    if (currmenu == MMAIN)
+        for (s = sclist; s != NULL; s = s->next)
+            if (s->scfunc == do_toggle_void)
+		ptr += sprintf(ptr, "(%s)\t\t\t%s %s\n",
+		    s->keystr, _(flagtostr(s->toggle)), _("enable/disable"));
+
+
+#ifdef ENABLE_NANORC
+    if (old_whitespace)
+	SET(WHITESPACE_DISPLAY);
+#endif
+#endif
+
+    /* If all went well, we didn't overwrite the allocated space for
+     * help_text. */
+    assert(strlen(help_text) <= allocsize + 1);
+}
+
+/* Determine the shortcut key corresponding to the values of kbinput
+ * (the key itself), meta_key (whether the key is a meta sequence), and
+ * func_key (whether the key is a function key), if any.  In the
+ * process, convert certain non-shortcut keys into their corresponding
+ * shortcut keys. */
+void parse_help_input(int *kbinput, bool *meta_key, bool *func_key)
+{
+    get_shortcut(MHELP, kbinput, meta_key, func_key);
+
+    if (!*meta_key) {
+	switch (*kbinput) {
+	    /* For consistency with the file browser. */
+	    case ' ':
+		*kbinput = sc_seq_or(do_page_up, 0);
+		break;
+	    case '-':
+		*kbinput = sc_seq_or(do_page_down, 0);;
+		break;
+	    /* Cancel is equivalent to Exit here. */
+	    case 'E':
+	    case 'e':
+		*kbinput = sc_seq_or(do_exit, 0);;
+		break;
+	}
+    }
+}
+
+/* Calculate the next line of help_text, starting at ptr. */
+size_t help_line_len(const char *ptr)
+{
+    int help_cols = (COLS > 24) ? COLS - 1 : 24;
+
+    /* Try to break the line at (COLS - 1) columns if we have more than
+     * 24 columns, and at 24 columns otherwise. */
+    ssize_t wrap_loc = break_line(ptr, help_cols, TRUE);
+    size_t retval = (wrap_loc < 0) ? 0 : wrap_loc;
+    size_t retval_save = retval;
+
+    /* Get the length of the entire line up to a null or a newline. */
+    while (*(ptr + retval) != '\0' && *(ptr + retval) != '\n')
+	retval += move_mbright(ptr + retval, 0);
+
+    /* If the entire line doesn't go more than one column beyond where
+     * we tried to break it, we should display it as-is.  Otherwise, we
+     * should display it only up to the break. */
+    if (strnlenpt(ptr, retval) > help_cols + 1)
+	retval = retval_save;
+
+    return retval;
+}
+
+#endif /* !DISABLE_HELP */
+
+/* Start the help browser for the edit window. */
+void do_help_void(void)
+{
+
+#ifndef DISABLE_HELP
+    /* Start the help browser for the edit window. */
+    do_help(&edit_refresh);
+#else
+    if (currmenu == MMAIN)
+	nano_disabled_msg();
+    else
+	beep();
+#endif
+}
diff --git a/src/move.c b/src/move.c
new file mode 100644
index 0000000..468a02f
--- /dev/null
+++ b/src/move.c
@@ -0,0 +1,670 @@
+/* $Id: move.c 4486 2010-03-21 04:56:37Z astyanax $ */
+/**************************************************************************
+ *   move.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 <string.h>
+#include <ctype.h>
+
+/* Move to the first line of the file. */
+void do_first_line(void)
+{
+    openfile->current = openfile->edittop = openfile->fileage;
+    openfile->current_x = 0;
+    openfile->placewewant = 0;
+
+    edit_refresh_needed = 1;
+}
+
+/* Move to the last line of the file. */
+void do_last_line(void)
+{
+    openfile->current = openfile->filebot;
+    openfile->current_x = strlen(openfile->filebot->data);
+    openfile->placewewant = xplustabs();
+    openfile->current_y = editwinrows - 1;
+
+    edit_refresh_needed = 1;
+}
+
+/* Move up one page. */
+void do_page_up(void)
+{
+    int i, skipped = 0;
+
+    /* If there's less than a page of text left on the screen, put the
+     * cursor at the beginning of the first line of the file, and then
+     * update the edit window. */
+    if (openfile->current->lineno == 1 || (!ISSET(SOFTWRAP) &&
+	openfile->current->lineno <= editwinrows - 2)) {
+	do_first_line();
+	return;
+    }
+
+    /* If we're not in smooth scrolling mode, put the cursor at the
+     * beginning of the top line of the edit window, as Pico does. */
+
+#ifndef NANO_TINY
+    if (!ISSET(SMOOTH_SCROLL)) {
+#endif
+	openfile->current = openfile->edittop;
+	openfile->placewewant = openfile->current_y = 0;
+#ifndef NANO_TINY
+    }
+#endif
+
+    for (i = editwinrows - 2; i - skipped > 0 && openfile->current !=
+	openfile->fileage; i--) {
+	openfile->current = openfile->current->prev;
+	if (ISSET(SOFTWRAP) && openfile->current) {
+	    skipped += strlenpt(openfile->current->data) / COLS;
+#ifdef DEBUG
+    fprintf(stderr, "do_page_up: i = %d, skipped = %d based on line %ld len %d\n", i, (unsigned long) skipped, 
+openfile->current->lineno, strlenpt(openfile->current->data));
+#endif
+	}
+    }
+
+    openfile->current_x = actual_x(openfile->current->data,
+	openfile->placewewant);
+
+#ifdef DEBUG
+    fprintf(stderr, "do_page_up: openfile->current->lineno = %lu, skipped = %d\n", (unsigned long) openfile->current->lineno, skipped);
+#endif
+
+    /* Scroll the edit window up a page. */
+    edit_update(NONE);
+}
+
+/* Move down one page. */
+void do_page_down(void)
+{
+    int i;
+
+    /* If there's less than a page of text left on the screen, put the
+     * cursor at the beginning of the last line of the file, and then
+     * update the edit window. */
+    if (openfile->current->lineno + maxrows - 2 >=
+	openfile->filebot->lineno) {
+	do_last_line();
+	return;
+    }
+
+    /* If we're not in smooth scrolling mode, put the cursor at the
+     * beginning of the top line of the edit window, as Pico does. */
+#ifndef NANO_TINY
+    if (!ISSET(SMOOTH_SCROLL)) {
+#endif
+	openfile->current = openfile->edittop;
+	openfile->placewewant = openfile->current_y = 0;
+#ifndef NANO_TINY
+    }
+#endif
+
+    for (i = maxrows - 2; i > 0 && openfile->current !=
+	openfile->filebot; i--) {
+	openfile->current = openfile->current->next;
+#ifdef DEBUG
+    fprintf(stderr, "do_page_down: moving to line %lu\n", (unsigned long) openfile->current->lineno);
+#endif
+
+    }
+
+    openfile->current_x = actual_x(openfile->current->data,
+	openfile->placewewant);
+
+    /* Scroll the edit window down a page. */
+    edit_update(NONE);
+}
+
+#ifndef DISABLE_JUSTIFY
+/* Move up to the beginning of the last beginning-of-paragraph line
+ * before the current line.  If allow_update is TRUE, update the screen
+ * afterwards. */
+void do_para_begin(bool allow_update)
+{
+    filestruct *current_save = openfile->current;
+    const size_t pww_save = openfile->placewewant;
+
+    if (openfile->current != openfile->fileage) {
+	do {
+	    openfile->current = openfile->current->prev;
+	    openfile->current_y--;
+	} while (!begpar(openfile->current));
+    }
+
+    openfile->current_x = 0;
+    openfile->placewewant = 0;
+
+    if (allow_update)
+	edit_redraw(current_save, pww_save);
+}
+
+/* Move up to the beginning of the last beginning-of-paragraph line
+ * before the current line, and update the screen afterwards. */
+void do_para_begin_void(void)
+{
+    do_para_begin(TRUE);
+}
+
+/* Move down to the beginning of the last line of the current paragraph.
+ * Then move down one line farther if there is such a line, or to the
+ * end of the current line if not.  If allow_update is TRUE, update the
+ * screen afterwards.  A line is the last line of a paragraph if it is
+ * in a paragraph, and the next line either is the beginning line of a
+ * paragraph or isn't in a paragraph. */
+void do_para_end(bool allow_update)
+{
+    filestruct *const current_save = openfile->current;
+    const size_t pww_save = openfile->placewewant;
+
+    while (openfile->current != openfile->filebot &&
+	!inpar(openfile->current))
+	openfile->current = openfile->current->next;
+
+    while (openfile->current != openfile->filebot &&
+	inpar(openfile->current->next) &&
+	!begpar(openfile->current->next)) {
+	openfile->current = openfile->current->next;
+	openfile->current_y++;
+    }
+
+    if (openfile->current != openfile->filebot) {
+	openfile->current = openfile->current->next;
+	openfile->current_x = 0;
+	openfile->placewewant = 0;
+    } else {
+	openfile->current_x = strlen(openfile->current->data);
+	openfile->placewewant = xplustabs();
+    }
+
+    if (allow_update)
+	edit_redraw(current_save, pww_save);
+}
+
+/* Move down to the beginning of the last line of the current paragraph.
+ * Then move down one line farther if there is such a line, or to the
+ * end of the current line if not, and update the screen afterwards. */
+void do_para_end_void(void)
+{
+    do_para_end(TRUE);
+}
+#endif /* !DISABLE_JUSTIFY */
+
+#ifndef NANO_TINY
+/* Move to the next word in the file.  If allow_punct is TRUE, treat
+ * punctuation as part of a word.  If allow_update is TRUE, update the
+ * screen afterwards.  Return TRUE if we started on a word, and FALSE
+ * otherwise. */
+bool do_next_word(bool allow_punct, bool allow_update)
+{
+    size_t pww_save = openfile->placewewant;
+    filestruct *current_save = openfile->current;
+    char *char_mb;
+    int char_mb_len;
+    bool end_line = FALSE, started_on_word = FALSE;
+
+    assert(openfile->current != NULL && openfile->current->data != NULL);
+
+    char_mb = charalloc(mb_cur_max());
+
+    /* Move forward until we find the character after the last letter of
+     * the current word. */
+    while (!end_line) {
+	char_mb_len = parse_mbchar(openfile->current->data +
+		openfile->current_x, char_mb, NULL);
+
+	/* If we've found it, stop moving forward through the current
+	 * line. */
+	if (!is_word_mbchar(char_mb, allow_punct))
+	    break;
+
+	/* If we haven't found it, then we've started on a word, so set
+	 * started_on_word to TRUE. */
+	started_on_word = TRUE;
+
+	if (openfile->current->data[openfile->current_x] == '\0')
+	    end_line = TRUE;
+	else
+	    openfile->current_x += char_mb_len;
+    }
+
+    /* Move forward until we find the first letter of the next word. */
+    if (openfile->current->data[openfile->current_x] == '\0')
+	end_line = TRUE;
+    else
+	openfile->current_x += char_mb_len;
+
+    for (; openfile->current != NULL;
+	openfile->current = openfile->current->next) {
+	while (!end_line) {
+	    char_mb_len = parse_mbchar(openfile->current->data +
+		openfile->current_x, char_mb, NULL);
+
+	    /* If we've found it, stop moving forward through the
+	     * current line. */
+	    if (is_word_mbchar(char_mb, allow_punct))
+		break;
+
+	    if (openfile->current->data[openfile->current_x] == '\0')
+		end_line = TRUE;
+	    else
+		openfile->current_x += char_mb_len;
+	}
+
+	/* If we've found it, stop moving forward to the beginnings of
+	 * subsequent lines. */
+	if (!end_line)
+	    break;
+
+	if (openfile->current != openfile->filebot) {
+	    end_line = FALSE;
+	    openfile->current_x = 0;
+	}
+    }
+
+    free(char_mb);
+
+    /* If we haven't found it, move to the end of the file. */
+    if (openfile->current == NULL)
+	openfile->current = openfile->filebot;
+
+    openfile->placewewant = xplustabs();
+
+    /* If allow_update is TRUE, update the screen. */
+    if (allow_update)
+	edit_redraw(current_save, pww_save);
+
+    /* Return whether we started on a word. */
+    return started_on_word;
+}
+
+/* Move to the next word in the file, treating punctuation as part of a
+ * word if the WORD_BOUNDS flag is set, and update the screen
+ * afterwards. */
+void do_next_word_void(void)
+{
+    do_next_word(ISSET(WORD_BOUNDS), TRUE);
+}
+
+/* Move to the previous word in the file.  If allow_punct is TRUE, treat
+ * punctuation as part of a word.  If allow_update is TRUE, update the
+ * screen afterwards.  Return TRUE if we started on a word, and FALSE
+ * otherwise. */
+bool do_prev_word(bool allow_punct, bool allow_update)
+{
+    size_t pww_save = openfile->placewewant;
+    filestruct *current_save = openfile->current;
+    char *char_mb;
+    int char_mb_len;
+    bool begin_line = FALSE, started_on_word = FALSE;
+
+    assert(openfile->current != NULL && openfile->current->data != NULL);
+
+    char_mb = charalloc(mb_cur_max());
+
+    /* Move backward until we find the character before the first letter
+     * of the current word. */
+    while (!begin_line) {
+	char_mb_len = parse_mbchar(openfile->current->data +
+		openfile->current_x, char_mb, NULL);
+
+	/* If we've found it, stop moving backward through the current
+	 * line. */
+	if (!is_word_mbchar(char_mb, allow_punct))
+	    break;
+
+	/* If we haven't found it, then we've started on a word, so set
+	 * started_on_word to TRUE. */
+	started_on_word = TRUE;
+
+	if (openfile->current_x == 0)
+	    begin_line = TRUE;
+	else
+	    openfile->current_x = move_mbleft(openfile->current->data,
+		openfile->current_x);
+    }
+
+    /* Move backward until we find the last letter of the previous
+     * word. */
+    if (openfile->current_x == 0)
+	begin_line = TRUE;
+    else
+	openfile->current_x = move_mbleft(openfile->current->data,
+		openfile->current_x);
+
+    for (; openfile->current != NULL;
+	openfile->current = openfile->current->prev) {
+	while (!begin_line) {
+	    char_mb_len = parse_mbchar(openfile->current->data +
+		openfile->current_x, char_mb, NULL);
+
+	    /* If we've found it, stop moving backward through the
+	     * current line. */
+	    if (is_word_mbchar(char_mb, allow_punct))
+		break;
+
+	    if (openfile->current_x == 0)
+		begin_line = TRUE;
+	    else
+		openfile->current_x =
+			move_mbleft(openfile->current->data,
+			openfile->current_x);
+	}
+
+	/* If we've found it, stop moving backward to the ends of
+	 * previous lines. */
+	if (!begin_line)
+	    break;
+
+	if (openfile->current != openfile->fileage) {
+	    begin_line = FALSE;
+	    openfile->current_x = strlen(openfile->current->prev->data);
+	}
+    }
+
+    /* If we haven't found it, move to the beginning of the file. */
+    if (openfile->current == NULL)
+	openfile->current = openfile->fileage;
+    /* If we've found it, move backward until we find the character
+     * before the first letter of the previous word. */
+    else if (!begin_line) {
+	if (openfile->current_x == 0)
+	    begin_line = TRUE;
+	else
+	    openfile->current_x = move_mbleft(openfile->current->data,
+		openfile->current_x);
+
+	while (!begin_line) {
+	    char_mb_len = parse_mbchar(openfile->current->data +
+		openfile->current_x, char_mb, NULL);
+
+	    /* If we've found it, stop moving backward through the
+	     * current line. */
+	    if (!is_word_mbchar(char_mb, allow_punct))
+		break;
+
+	    if (openfile->current_x == 0)
+		begin_line = TRUE;
+	    else
+		openfile->current_x =
+			move_mbleft(openfile->current->data,
+			openfile->current_x);
+	}
+
+	/* If we've found it, move forward to the first letter of the
+	 * previous word. */
+	if (!begin_line)
+	    openfile->current_x += char_mb_len;
+    }
+
+    free(char_mb);
+
+    openfile->placewewant = xplustabs();
+
+    /* If allow_update is TRUE, update the screen. */
+    if (allow_update)
+	edit_redraw(current_save, pww_save);
+
+    /* Return whether we started on a word. */
+    return started_on_word;
+}
+
+/* Move to the previous word in the file, treating punctuation as part
+ * of a word if the WORD_BOUNDS flag is set, and update the screen
+ * afterwards. */
+void do_prev_word_void(void)
+{
+    do_prev_word(ISSET(WORD_BOUNDS), TRUE);
+}
+#endif /* !NANO_TINY */
+
+/* Move to the beginning of the current line.  If the SMART_HOME flag is
+ * set, move to the first non-whitespace character of the current line
+ * if we aren't already there, or to the beginning of the current line
+ * if we are. */
+void do_home(void)
+{
+    size_t pww_save = openfile->placewewant;
+
+#ifndef NANO_TINY
+    if (ISSET(SMART_HOME)) {
+	size_t current_x_save = openfile->current_x;
+
+	openfile->current_x = indent_length(openfile->current->data);
+
+	if (openfile->current_x == current_x_save ||
+		openfile->current->data[openfile->current_x] == '\0')
+	    openfile->current_x = 0;
+
+	openfile->placewewant = xplustabs();
+    } else {
+#endif
+	openfile->current_x = 0;
+	openfile->placewewant = 0;
+#ifndef NANO_TINY
+    }
+#endif
+
+    if (need_horizontal_update(pww_save))
+	update_line(openfile->current, openfile->current_x);
+}
+
+/* Move to the end of the current line. */
+void do_end(void)
+{
+    size_t pww_save = openfile->placewewant;
+
+    openfile->current_x = strlen(openfile->current->data);
+    openfile->placewewant = xplustabs();
+
+    if (need_horizontal_update(pww_save))
+	update_line(openfile->current, openfile->current_x);
+}
+
+/* If scroll_only is FALSE, move up one line.  If scroll_only is TRUE,
+ * scroll up one line without scrolling the cursor. */
+void do_up(
+#ifndef NANO_TINY
+	bool scroll_only
+#else
+	void
+#endif
+	)
+{
+    /* If we're at the top of the file, or if scroll_only is TRUE and
+     * the top of the file is onscreen, get out. */
+    if (openfile->current == openfile->fileage
+#ifndef NANO_TINY
+	|| (scroll_only && openfile->edittop == openfile->fileage)
+#endif
+	)
+	return;
+
+    assert(ISSET(SOFTWRAP) || openfile->current_y == openfile->current->lineno - openfile->edittop->lineno);
+
+    /* Move the current line of the edit window up. */
+    openfile->current = openfile->current->prev;
+    openfile->current_x = actual_x(openfile->current->data,
+	openfile->placewewant);
+
+    /* If scroll_only is FALSE and if we're on the first line of the
+     * edit window, scroll the edit window up one line if we're in
+     * smooth scrolling mode, or up half a page if we're not.  If
+     * scroll_only is TRUE, scroll the edit window up one line
+     * unconditionally. */
+    if (openfile->current_y == 0 || (ISSET(SOFTWRAP) && openfile->edittop->lineno == openfile->current->next->lineno)
+#ifndef NANO_TINY
+	|| scroll_only
+#endif
+	)
+	edit_scroll(UP_DIR,
+#ifndef NANO_TINY
+		(ISSET(SMOOTH_SCROLL) || scroll_only) ? 1 :
+#endif
+		editwinrows / 2 + 1);
+
+    /* If we're below the first line of the edit window, update the
+     * line we were on before and the line we're on now.  The former
+     * needs to be redrawn if we're not on the first page, and the
+     * latter needs to be drawn unconditionally. */
+    if (openfile->current_y > 0) {
+	if (need_vertical_update(0))
+	    update_line(openfile->current->next, 0);
+	update_line(openfile->current, openfile->current_x);
+    }
+}
+
+/* Move up one line. */
+void do_up_void(void)
+{
+    do_up(
+#ifndef NANO_TINY
+	FALSE
+#endif
+	);
+}
+
+#ifndef NANO_TINY
+/* Scroll up one line without scrolling the cursor. */
+void do_scroll_up(void)
+{
+    do_up(TRUE);
+}
+#endif
+
+/* If scroll_only is FALSE, move down one line.  If scroll_only is TRUE,
+ * scroll down one line without scrolling the cursor. */
+void do_down(
+#ifndef NANO_TINY
+	bool scroll_only
+#else
+	void
+#endif
+	)
+{
+    bool onlastline = FALSE;
+
+    /* If we're at the bottom of the file, get out. */
+    if (openfile->current == openfile->filebot)
+	return;
+
+
+    assert(ISSET(SOFTWRAP) || openfile->current_y == openfile->current->lineno - openfile->edittop->lineno);
+
+    /* Move the current line of the edit window down. */
+    openfile->current = openfile->current->next;
+    openfile->current_x = actual_x(openfile->current->data,
+	openfile->placewewant);
+
+    if (ISSET(SOFTWRAP)) {
+	if (openfile->current->lineno - openfile->edittop->lineno >= maxrows)
+	    onlastline = TRUE;
+    }
+
+    /* If scroll_only is FALSE and if we're on the first line of the
+     * edit window, scroll the edit window down one line if we're in
+     * smooth scrolling mode, or down half a page if we're not.  If
+     * scroll_only is TRUE, scroll the edit window down one line
+     * unconditionally. */
+    if (onlastline || openfile->current_y == editwinrows - 1
+#ifndef NANO_TINY
+	|| scroll_only
+#endif
+	) {
+	edit_scroll(DOWN_DIR,
+#ifndef NANO_TINY
+		(ISSET(SMOOTH_SCROLL) || scroll_only) ? 1 :
+#endif
+		editwinrows / 2 + 1);
+
+	edit_refresh_needed = TRUE;
+    }
+    /* If we're above the last line of the edit window, update the line
+     * we were on before and the line we're on now.  The former needs to
+     * be redrawn if we're not on the first page, and the latter needs
+     * to be drawn unconditionally. */
+    if (ISSET(SOFTWRAP) || openfile->current_y < editwinrows - 1) {
+	if (need_vertical_update(0))
+	    update_line(openfile->current->prev, 0);
+	update_line(openfile->current, openfile->current_x);
+    }
+}
+
+/* Move down one line. */
+void do_down_void(void)
+{
+    do_down(
+#ifndef NANO_TINY
+	FALSE
+#endif
+	);
+}
+
+#ifndef NANO_TINY
+/* Scroll down one line without scrolling the cursor. */
+void do_scroll_down(void)
+{
+    do_down(TRUE);
+}
+#endif
+
+/* Move left one character. */
+void do_left(void)
+{
+    size_t pww_save = openfile->placewewant;
+
+    if (openfile->current_x > 0)
+	openfile->current_x = move_mbleft(openfile->current->data,
+		openfile->current_x);
+    else if (openfile->current != openfile->fileage) {
+	do_up_void();
+	openfile->current_x = strlen(openfile->current->data);
+    }
+
+    openfile->placewewant = xplustabs();
+
+    if (need_horizontal_update(pww_save))
+	update_line(openfile->current, openfile->current_x);
+}
+
+/* Move right one character. */
+void do_right(void)
+{
+    size_t pww_save = openfile->placewewant;
+
+    assert(openfile->current_x <= strlen(openfile->current->data));
+
+    if (openfile->current->data[openfile->current_x] != '\0')
+	openfile->current_x = move_mbright(openfile->current->data,
+		openfile->current_x);
+    else if (openfile->current != openfile->filebot) {
+	do_down_void();
+	openfile->current_x = 0;
+    }
+
+    openfile->placewewant = xplustabs();
+
+    if (need_horizontal_update(pww_save))
+	update_line(openfile->current, openfile->current_x);
+}
diff --git a/src/nano.c b/src/nano.c
new file mode 100644
index 0000000..269ab29
--- /dev/null
+++ b/src/nano.c
@@ -0,0 +1,2735 @@
+/* $Id: nano.c 4530 2011-02-18 07:30:57Z astyanax $ */ 
+/**************************************************************************
+ *   nano.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 <stdarg.h>
+#include <signal.h>
+#include <unistd.h>
+#include <string.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <ctype.h>
+#include <locale.h>
+#include <time.h>
+#ifdef ENABLE_UTF8
+#include <langinfo.h>
+#endif
+#include <termios.h>
+#ifdef HAVE_GETOPT_H
+#include <getopt.h>
+#endif
+#ifndef NANO_TINY
+#include <sys/ioctl.h>
+#endif
+
+#ifndef DISABLE_MOUSE
+static int oldinterval = -1;
+	/* Used to store the user's original mouse click interval. */
+#endif
+#ifdef ENABLE_NANORC
+static bool no_rcfiles = FALSE;
+	/* Should we ignore all rcfiles? */
+#endif
+static struct termios oldterm;
+	/* 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;
+
+#ifdef ENABLE_COLOR
+    newnode->multidata = NULL;
+#endif
+
+    return newnode;
+}
+
+/* Make a copy of a filestruct node. */
+filestruct *copy_node(const filestruct *src)
+{
+    filestruct *dst;
+
+    assert(src != NULL);
+
+    dst = (filestruct *)nmalloc(sizeof(filestruct));
+
+    dst->data = mallocstrcpy(NULL, src->data);
+    dst->next = src->next;
+    dst->prev = src->prev;
+    dst->lineno = src->lineno;
+#ifdef ENABLE_COLOR
+    dst->multidata = NULL;
+#endif
+
+    return dst;
+}
+
+/* Splice a node into an existing filestruct. */
+void splice_node(filestruct *begin, filestruct *newnode, filestruct
+	*end)
+{
+    assert(newnode != NULL && begin != NULL);
+
+    newnode->next = end;
+    newnode->prev = begin;
+    begin->next = newnode;
+    if (end != NULL)
+	end->prev = newnode;
+}
+
+/* Unlink a node from the rest of the filestruct. */
+void unlink_node(const filestruct *fileptr)
+{
+    assert(fileptr != NULL);
+
+    if (fileptr->prev != NULL)
+	fileptr->prev->next = fileptr->next;
+    if (fileptr->next != NULL)
+	fileptr->next->prev = fileptr->prev;
+}
+
+/* Delete a node from the filestruct. */
+void delete_node(filestruct *fileptr)
+{
+    assert(fileptr != NULL && fileptr->data != NULL);
+
+    if (fileptr->data != NULL)
+	free(fileptr->data);
+
+#ifdef ENABLE_COLOR
+    if (fileptr->multidata)
+	free(fileptr->multidata);
+#endif
+
+    free(fileptr);
+}
+
+/* Duplicate a whole filestruct. */
+filestruct *copy_filestruct(const filestruct *src)
+{
+    filestruct *head, *copy;
+
+    assert(src != NULL);
+
+    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 filestruct. */
+void free_filestruct(filestruct *src)
+{
+    assert(src != NULL);
+
+    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;
+
+    assert(fileptr != NULL);
+
+    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;
+
+    /* Save the line above the top of the partition, detach the top of
+     * the partition from it, and save the text before top_x in
+     * top_data. */
+    p->top_prev = top->prev;
+    top->prev = NULL;
+    p->top_data = mallocstrncpy(NULL, top->data, top_x + 1);
+    p->top_data[top_x] = '\0';
+
+    /* Save the line below the bottom of the partition, detach the
+     * bottom of the partition from it, and save the text after bot_x in
+     * bot_data. */
+    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. */
+    null_at(&bot->data, bot_x);
+
+    /* 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);
+    align(&top->data);
+
+    /* 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)
+{
+    char *tmp;
+
+    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. */
+    tmp = mallocstrcpy(NULL, openfile->fileage->data);
+    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);
+    strcpy(openfile->fileage->data, (*p)->top_data);
+    free((*p)->top_data);
+    strcat(openfile->fileage->data, tmp);
+    free(tmp);
+
+    /* 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 move_to_filestruct(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;
+#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));
+#endif
+
+    /* Get the number of characters in the text, and subtract it from
+     * totsize. */
+    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;
+	}
+
+	/* Renumber starting with the line after the original
+	 * file_bot. */
+	if (file_bot_save->next != NULL)
+	    renumber(file_bot_save->next);
+    }
+
+    /* Since the text has now been saved, remove it from the
+     * filestruct. */
+    openfile->fileage = (filestruct *)nmalloc(sizeof(filestruct));
+    openfile->fileage->data = mallocstrcpy(NULL, "");
+    openfile->filebot = openfile->fileage;
+
+#ifdef ENABLE_COLOR
+    openfile->fileage->multidata = NULL;
+#endif
+
+    /* 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;
+    }
+#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)
+	edit_update(NONE);
+
+    /* Renumber starting with the beginning line of the old
+     * partition. */
+    renumber(top_save);
+
+    /* If the NO_NEWLINES flag isn't set, and the text doesn't end with
+     * a magicline, add a new magicline. */
+    if (!ISSET(NO_NEWLINES) && openfile->filebot->data[0] != '\0')
+	new_magicline();
+}
+
+/* Copy all the text from the filestruct beginning with file_top and
+ * ending with file_bot to the current filestruct at the current cursor
+ * position. */
+void copy_from_filestruct(filestruct *file_top, filestruct *file_bot)
+{
+    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(file_top != NULL && file_bot != 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 keep
+     * track of whether the top of the edit window is inside the
+     * partition. */
+    filepart = partition_filestruct(openfile->current,
+	openfile->current_x, openfile->current, openfile->current_x);
+    edittop_inside = (openfile->edittop == openfile->fileage);
+
+    /* Put the top and bottom of the filestruct at copies of file_top
+     * and file_bot. */
+    openfile->fileage = copy_filestruct(file_top);
+    openfile->filebot = openfile->fileage;
+    while (openfile->filebot->next != NULL)
+	openfile->filebot = openfile->filebot->next;
+
+    /* Restore the current line and cursor position.  If the mark begins
+     * inside the partition, adjust the mark coordinates to compensate
+     * for the change in the current line. */
+    openfile->current = openfile->filebot;
+    openfile->current_x = strlen(openfile->filebot->data);
+    if (openfile->fileage == openfile->filebot) {
+#ifndef NANO_TINY
+	if (openfile->mark_set) {
+	    openfile->mark_begin = openfile->current;
+	    if (!right_side_up)
+		openfile->mark_begin_x += openfile->current_x;
+	}
+#endif
+	openfile->current_x += current_x_save;
+    }
+#ifndef NANO_TINY
+    else if (openfile->mark_set) {
+	if (!right_side_up) {
+	    if (single_line) {
+		openfile->mark_begin = openfile->current;
+		openfile->mark_begin_x -= current_x_save;
+	    } else
+		openfile->mark_begin_x -= openfile->current_x;
+	}
+    }
+#endif
+
+    /* Get the number of characters in the copied text, and add it to
+     * totsize. */
+    openfile->totsize += get_totsize(openfile->fileage,
+	openfile->filebot);
+
+    /* Update the current y-coordinate to account for the number of
+     * lines the copied text has, less one since the first line will be
+     * tacked onto the current line. */
+    openfile->current_y += openfile->filebot->lineno - 1;
+
+    top_save = openfile->fileage;
+
+    /* If the top of the edit window is inside the partition, set it to
+     * where the copied text now starts. */
+    if (edittop_inside)
+	openfile->edittop = 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 NO_NEWLINES flag isn't set, and the text doesn't end with
+     * a magicline, add a new magicline. */
+    if (!ISSET(NO_NEWLINES) && openfile->filebot->data[0] != '\0')
+	new_magicline();
+}
+
+/* Create a new openfilestruct node. */
+openfilestruct *make_new_opennode(void)
+{
+    openfilestruct *newnode =
+	(openfilestruct *)nmalloc(sizeof(openfilestruct));
+
+    newnode->filename = NULL;
+    newnode->fileage = NULL;
+    newnode->filebot = NULL;
+    newnode->edittop = NULL;
+    newnode->current = NULL;
+#ifndef NANO_TINY
+    newnode->current_stat = NULL;
+    newnode->last_action = OTHER;
+#endif
+
+    return newnode;
+}
+
+/* Splice a node into an existing openfilestruct. */
+void splice_opennode(openfilestruct *begin, openfilestruct *newnode,
+	openfilestruct *end)
+{
+    assert(newnode != NULL && begin != NULL);
+
+    newnode->next = end;
+    newnode->prev = begin;
+    begin->next = newnode;
+
+    if (end != NULL)
+	end->prev = newnode;
+}
+
+/* Unlink a node from the rest of the openfilestruct, and delete it. */
+void unlink_opennode(openfilestruct *fileptr)
+{
+    assert(fileptr != NULL && fileptr->prev != NULL && fileptr->next != NULL && fileptr != fileptr->prev && fileptr != fileptr->next);
+
+    fileptr->prev->next = fileptr->next;
+    fileptr->next->prev = fileptr->prev;
+
+    delete_opennode(fileptr);
+}
+
+/* Delete a node from the openfilestruct. */
+void delete_opennode(openfilestruct *fileptr)
+{
+    assert(fileptr != NULL && fileptr->filename != NULL && fileptr->fileage != NULL);
+
+    free(fileptr->filename);
+    free_filestruct(fileptr->fileage);
+#ifndef NANO_TINY
+    if (fileptr->current_stat != NULL)
+	free(fileptr->current_stat);
+#endif
+
+    free(fileptr);
+}
+
+#ifdef DEBUG
+/* Deallocate all memory associated with this and later files, including
+ * the lines of text. */
+void free_openfilestruct(openfilestruct *src)
+{
+    assert(src != NULL);
+
+    while (src != src->next) {
+	src = src->next;
+	delete_opennode(src->prev);
+    }
+
+    delete_opennode(src);
+}
+#endif
+
+/* Display a warning about a key disabled in view mode. */
+void print_view_warning(void)
+{
+    statusbar(_("Key invalid in view mode"));
+}
+
+/* Make nano exit gracefully. */
+void finish(void)
+{
+    /* Blank the statusbar (and shortcut list, if applicable), and move
+     * the cursor to the last line of the screen. */
+    if (!ISSET(NO_HELP))
+	blank_bottombars();
+    else
+	blank_statusbar();
+    wrefresh(bottomwin);
+    endwin();
+
+    /* Restore the old terminal settings. */
+    tcsetattr(0, TCSANOW, &oldterm);
+
+#if !defined(NANO_TINY) && defined(ENABLE_NANORC)
+    if (!no_rcfiles && ISSET(HISTORYLOG))
+	save_history();
+    if (!no_rcfiles && 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);
+
+    /* Save the current file buffer if it's been modified. */
+    if (openfile && openfile->modified) {
+	/* If we've partitioned the filestruct, unpartition it now. */
+	if (filepart != NULL)
+	    unpartition_filestruct(&filepart);
+
+	die_save_file(openfile->filename
+#ifndef NANO_TINY
+		, openfile->current_stat
+#endif
+		);
+    }
+
+#ifdef ENABLE_MULTIBUFFER
+    /* Save all of the other modified file buffers, if any. */
+    if (openfile != NULL) {
+	openfilestruct *tmp = openfile;
+
+	while (tmp != openfile->next) {
+	    openfile = openfile->next;
+
+	    /* Save the current file buffer if it's been modified. */
+	    if (openfile->modified)
+		die_save_file(openfile->filename
+#ifndef NANO_TINY
+			, openfile->current_stat
+#endif
+			);
+	}
+    }
+#endif
+
+    /* Get out. */
+    exit(1);
+}
+
+/* Save the current file under the name spacified in die_filename, which
+ * is modified to be unique if necessary. */
+void die_save_file(const char *die_filename
+#ifndef NANO_TINY
+	, struct stat *die_stat
+#endif
+	)
+{
+    char *retval;
+    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";
+
+    retval = get_next_filename(die_filename, ".save");
+    if (retval[0] != '\0')
+	failed = !write_file(retval, NULL, TRUE, OVERWRITE, TRUE);
+
+    if (!failed)
+	fprintf(stderr, _("\nBuffer written to %s\n"), retval);
+    else if (retval[0] != '\0')
+	fprintf(stderr, _("\nBuffer not written to %s: %s\n"), retval,
+		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
+       dont worry if it fails because we're supposed to be bailing as fast
+       as possible. */
+    if (die_stat) {
+	int shush;
+	shush = chmod(retval, die_stat->st_mode);
+	shush = chown(retval, die_stat->st_uid, die_stat->st_gid);
+    }
+#endif
+
+    free(retval);
+}
+
+/* Initialize the three window portions nano uses. */
+void window_init(void)
+{
+    /* If the screen height is too small, get out. */
+    editwinrows = LINES - 5 + no_more_space() + no_help();
+    if (COLS < MIN_EDITOR_COLS || editwinrows < MIN_EDITOR_ROWS)
+	die(_("Window size is too small for nano...\n"));
+
+#ifndef DISABLE_WRAPJUSTIFY
+    /* Set up fill, based on the screen width. */
+    fill = wrap_at;
+    if (fill <= 0)
+	fill += COLS;
+    if (fill < 0)
+	fill = 0;
+#endif
+
+    if (topwin != NULL)
+	delwin(topwin);
+    if (edit != NULL)
+	delwin(edit);
+    if (bottomwin != NULL)
+	delwin(bottomwin);
+
+    /* Set up the windows. */
+    topwin = newwin(2 - no_more_space(), COLS, 0, 0);
+    edit = newwin(editwinrows, COLS, 2 - no_more_space(), 0);
+    bottomwin = newwin(3 - no_help(), COLS, editwinrows + (2 -
+	no_more_space()), 0);
+
+    /* Turn the keypad on for the windows, if necessary. */
+    if (!ISSET(REBIND_KEYPAD)) {
+	keypad(topwin, TRUE);
+	keypad(edit, TRUE);
+	keypad(bottomwin, TRUE);
+    }
+}
+
+#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 */
+
+#ifdef HAVE_GETOPT_LONG
+#define print_opt(shortflag, longflag, desc) print_opt_full(shortflag, longflag, desc)
+#else
+#define print_opt(shortflag, longflag, desc) print_opt_full(shortflag, desc)
+#endif
+
+/* 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_full(const char *shortflag
+#ifdef HAVE_GETOPT_LONG
+	, const char *longflag
+#endif
+	, const char *desc)
+{
+    printf(" %s\t", shortflag);
+    if (strlenpt(shortflag) < 8)
+	printf("\t");
+
+#ifdef HAVE_GETOPT_LONG
+    printf("%s\t", longflag);
+    if (strlenpt(longflag) < 8)
+	printf("\t\t");
+    else if (strlenpt(longflag) < 16)
+	printf("\t");
+#endif
+
+    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"));
+    printf(
+#ifdef HAVE_GETOPT_LONG
+	_("Option\t\tGNU long option\t\tMeaning\n")
+#else
+	_("Option\t\tMeaning\n")
+#endif
+	);
+    print_opt("-h, -?", "--help", N_("Show this message"));
+    print_opt(_("+LINE,COLUMN"), "",
+	N_("Start at line LINE, column COLUMN"));
+#ifndef NANO_TINY
+    print_opt("-A", "--smarthome", N_("Enable smart home key"));
+    print_opt("-B", "--backup", N_("Save backups of existing files"));
+    print_opt(_("-C <dir>"), _("--backupdir=<dir>"),
+	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
+#ifdef ENABLE_MULTIBUFFER
+    print_opt("-F", "--multibuffer", N_("Enable multiple file buffers"));
+#endif
+#ifdef ENABLE_NANORC
+#ifndef NANO_TINY
+    print_opt("-H", "--historylog",
+	N_("Log & read search/replace string history"));
+#endif
+    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 NANO_TINY
+    print_opt("-P", "--poslog",
+	N_("Log & read location of cursor position"));
+#endif
+#ifndef DISABLE_JUSTIFY
+    print_opt(_("-Q <str>"), _("--quotestr=<str>"),
+	N_("Quoting string"));
+#endif
+    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"));
+#endif
+#ifdef ENABLE_COLOR
+    print_opt(_("-Y <str>"), _("--syntax=<str>"),
+	N_("Syntax definition to use for coloring"));
+#endif
+    print_opt("-c", "--const", N_("Constantly show cursor position"));
+    print_opt("-d", "--rebinddelete",
+	N_("Fix Backspace/Delete confusion problem"));
+#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
+    print_opt("-l", "--nofollow",
+	N_("Don't follow symbolic links, overwrite"));
+#ifndef DISABLE_MOUSE
+    print_opt("-m", "--mouse", N_("Enable the use of the mouse"));
+#endif
+#ifndef DISABLE_OPERATINGDIR
+    print_opt(_("-o <dir>"), _("--operatingdir=<dir>"),
+	N_("Set operating directory"));
+#endif
+    print_opt("-p", "--preserve",
+	N_("Preserve XON (^Q) and XOFF (^S) keys"));
+    print_opt("-q", "--quiet",
+	N_("Silently ignore startup issues like rc file errors"));
+#ifndef DISABLE_WRAPJUSTIFY
+    print_opt(_("-r <#cols>"), _("--fill=<#cols>"),
+	N_("Set wrapping point at column #cols"));
+#endif
+#ifndef DISABLE_SPELLER
+    print_opt(_("-s <prog>"), _("--speller=<prog>"),
+	N_("Enable alternate speller"));
+#endif
+    print_opt("-t", "--tempfile",
+	N_("Auto save on exit, don't prompt"));
+#ifndef NANO_TINY
+    print_opt("-u", "--undo", N_("Allow generic undo [EXPERIMENTAL]"));
+#endif
+
+    print_opt("-v", "--view", N_("View mode (read-only)"));
+#ifndef DISABLE_WRAPPING
+    print_opt("-w", "--nowrap", N_("Don't wrap long lines"));
+#endif
+    print_opt("-x", "--nohelp", N_("Don't show the two help lines"));
+    print_opt("-z", "--suspend", N_("Enable suspension"));
+    print_opt("-$", "--softwrap", N_("Enable soft line wrapping"));
+
+    /* This is a special case. */
+    print_opt("-a, -b, -e,", "", NULL);
+    print_opt("-f, -g, -j", "", N_("(ignored, for Pico compatibility)"));
+
+    exit(0);
+}
+
+/* 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)
+{
+    printf(_(" GNU nano version %s (compiled %s, %s)\n"), VERSION,
+	__TIME__, __DATE__);
+    printf(" (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,\n");
+    printf(" 2008, 2009 Free Software Foundation, Inc.\n");
+    printf(
+	_(" Email: nano@nano-editor.org	Web: http://www.nano-editor.org/"));
+    printf(_("\n Compiled options:"));
+
+#ifdef DISABLE_BROWSER
+    printf(" --disable-browser");
+#endif
+#ifdef DISABLE_HELP
+    printf(" --disable-help");
+#endif
+#ifdef DISABLE_JUSTIFY
+    printf(" --disable-justify");
+#endif
+#ifdef DISABLE_MOUSE
+    printf(" --disable-mouse");
+#endif
+#ifndef ENABLE_NLS
+    printf(" --disable-nls");
+#endif
+#ifdef DISABLE_OPERATINGDIR
+    printf(" --disable-operatingdir");
+#endif
+#ifdef DISABLE_SPELLER
+    printf(" --disable-speller");
+#endif
+#ifdef DISABLE_TABCOMP
+    printf(" --disable-tabcomp");
+#endif
+#ifdef DISABLE_WRAPPING
+    printf(" --disable-wrapping");
+#endif
+#ifdef DISABLE_ROOTWRAPPING
+    printf(" --disable-wrapping-as-root");
+#endif
+#ifdef ENABLE_COLOR
+    printf(" --enable-color");
+#endif
+#ifdef DEBUG
+    printf(" --enable-debug");
+#endif
+#ifdef NANO_EXTRA
+    printf(" --enable-extra");
+#endif
+#ifdef ENABLE_MULTIBUFFER
+    printf(" --enable-multibuffer");
+#endif
+#ifdef ENABLE_NANORC
+    printf(" --enable-nanorc");
+#endif
+#ifdef NANO_TINY
+    printf(" --enable-tiny");
+#endif
+#ifdef ENABLE_UTF8
+    printf(" --enable-utf8");
+#endif
+#ifdef USE_SLANG
+    printf(" --with-slang");
+#endif
+    printf("\n");
+}
+
+/* Return 1 if the MORE_SPACE flag is set, and 0 otherwise.  This is
+ * used to calculate the relative screen position while taking this flag
+ * into account, since it adds one line to the edit window. */
+int no_more_space(void)
+{
+    return ISSET(MORE_SPACE) ? 1 : 0;
+}
+
+/* Return 2 if the NO_HELP flag is set, and 0 otherwise.  This is used
+ * to calculate the relative screen position while taking this flag into
+ * account, since it removes two lines from the edit window. */
+int no_help(void)
+{
+    return ISSET(NO_HELP) ? 2 : 0;
+}
+
+/* Indicate a disabled function on the statusbar. */
+void nano_disabled_msg(void)
+{
+    statusbar(_("Sorry, support for this function has been disabled"));
+}
+
+/* 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, 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, pretend the user chose to save. */
+    else if (ISSET(TEMP_FILE))
+	i = 1;
+    /* Otherwise, ask the user whether or not to save. */
+    else
+	i = do_yesno_prompt(FALSE,
+		_("Save modified buffer (ANSWERING \"No\" WILL DESTROY 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))) {
+#ifdef ENABLE_MULTIBUFFER
+	/* Exit only if there are no more open file buffers. */
+	if (!close_buffer())
+#endif
+	    finish();
+    /* If the user canceled, we go on. */
+    } else if (i != 1)
+	statusbar(_("Cancelled"));
+
+    shortcut_init(FALSE);
+    display_main_list();
+}
+
+/* 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);
+    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)
+{
+    /* Currently do nothing, just handle the intr silently */
+    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"));
+
+    /* 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. */
+#ifndef NANO_TINY
+    enable_signals();
+#endif
+
+    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);
+    sigaction(SIGQUIT, &act, NULL);
+
+    /* Trap SIGHUP and SIGTERM because we want to write the file out. */
+    act.sa_handler = handle_hupterm;
+    sigaction(SIGHUP, &act, NULL);
+    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);
+    allow_pending_sigwinch(FALSE);
+#endif
+
+    /* Trap normal suspend (^Z) so we can handle it ourselves. */
+    if (!ISSET(SUSPEND)) {
+	act.sa_handler = SIG_IGN;
+	sigaction(SIGTSTP, &act, NULL);
+    } 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;
+	sigaction(SIGTSTP, &act, NULL);
+
+	act.sa_handler = do_continue;
+	sigaction(SIGCONT, &act, NULL);
+    }
+}
+
+/* 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)
+{
+
+    if (ISSET(RESTRICTED)) {
+        nano_disabled_msg();
+	return;
+    }
+
+#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;
+    sigaction(SIGHUP, &act, NULL);
+    sigaction(SIGTERM, &act, NULL);
+
+    /* Do what mutt does: send ourselves a SIGSTOP. */
+    kill(0, SIGSTOP);
+}
+
+/* the subnfunc version */
+void do_suspend_void(void)
+{
+    if (ISSET(SUSPEND))
+	do_suspend(0);
+}
+
+/* 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.  Handle it,
+     * and restore the terminal to its previous state and update the
+     * screen in the process. */
+    handle_sigwinch(0);
+#else
+    /* Restore the terminal to its previous state. */
+    terminal_init();
+
+    /* Turn the cursor back on for sure. */
+    curs_set(1);
+
+    /* Redraw the contents of the windows that need it. */
+    blank_statusbar();
+    wnoutrefresh(bottomwin);
+    total_refresh();
+#endif
+}
+
+#ifndef NANO_TINY
+/* Handler for SIGWINCH (window size change). */
+RETSIGTYPE handle_sigwinch(int signal)
+{
+    const char *tty = ttyname(0);
+    int fd, result = 0;
+    struct winsize win;
+
+    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 REDEFINIG_MACROS_OK
+    COLS = win.ws_col;
+    LINES = win.ws_row;
+#endif
+
+    /* If we've partitioned the filestruct, unpartition it now. */
+    if (filepart != NULL)
+	unpartition_filestruct(&filepart);
+
+#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();
+
+    /* Turn the cursor back on for sure. */
+    curs_set(1);
+
+    /* 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. */
+    blank_statusbar();
+    wnoutrefresh(bottomwin);
+    currmenu = MMAIN;
+    total_refresh();
+
+    /* Jump back to either main() or the unjustify routine in
+     * do_justify(). */
+    siglongjmp(jump_buf, 1);
+}
+
+/* If allow is TRUE, block any SIGWINCH signals that we get, so that we
+ * can deal with them later.  If allow is FALSE, unblock any SIGWINCH
+ * signals that we have, so that we can deal with them now. */
+void allow_pending_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 which. */
+void do_toggle(int flag)
+{
+    bool enabled;
+    char *desc;
+
+    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;
+#ifdef ENABLE_NANORC
+	case WHITESPACE_DISPLAY:
+	    titlebar(NULL);
+	    edit_refresh();
+	    break;
+#endif
+#ifdef ENABLE_COLOR
+	case NO_COLOR_SYNTAX:
+	    edit_refresh();
+	    break;
+#endif
+	case SOFTWRAP:
+	    total_refresh();
+	    break;
+    }
+
+    enabled = ISSET(flag);
+
+    if (flag ==  NO_HELP
+#ifndef DISABLE_WRAPPING
+	|| flag == NO_WRAP
+#endif
+#ifdef ENABLE_COLOR
+	|| flag == NO_COLOR_SYNTAX
+#endif
+	)
+	enabled = !enabled;
+
+    desc = _(flagtostr(flag));
+    statusbar("%s %s", desc, 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)
+{
+    struct termios term;
+
+    tcgetattr(0, &term);
+    term.c_lflag &= ~IEXTEN;
+    term.c_oflag &= ~OPOST;
+    tcsetattr(0, TCSANOW, &term);
+}
+
+/* Disable interpretation of the special control keys in our terminal
+ * settings. */
+void disable_signals(void)
+{
+    struct termios term;
+
+    tcgetattr(0, &term);
+    term.c_lflag &= ~ISIG;
+    tcsetattr(0, TCSANOW, &term);
+}
+
+#ifndef NANO_TINY
+/* Enable interpretation of the special control keys in our terminal
+ * settings. */
+void enable_signals(void)
+{
+    struct termios term;
+
+    tcgetattr(0, &term);
+    term.c_lflag |= ISIG;
+    tcsetattr(0, TCSANOW, &term);
+}
+#endif
+
+/* Disable interpretation of the flow control characters in our terminal
+ * settings. */
+void disable_flow_control(void)
+{
+    struct termios term;
+
+    tcgetattr(0, &term);
+    term.c_iflag &= ~IXON;
+    tcsetattr(0, TCSANOW, &term);
+}
+
+/* Enable interpretation of the flow control characters in our terminal
+ * settings. */
+void enable_flow_control(void)
+{
+    struct termios term;
+
+    tcgetattr(0, &term);
+    term.c_iflag |= IXON;
+    tcsetattr(0, TCSANOW, &term);
+}
+
+/* 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
+}
+
+/* Read in a character, interpret it as a shortcut or toggle if
+ * necessary, and return it.  Set meta_key to TRUE if the character is a
+ * meta sequence, set func_key to TRUE if the character is a function
+ * key, set s_or_t to TRUE if the character is a shortcut or toggle
+ * key, set ran_func to TRUE if we ran a function associated with a
+ * shortcut key, and set finished to TRUE if we're done after running
+ * or trying to run a function associated with a shortcut key.  If
+ * allow_funcs is FALSE, don't actually run any functions associated
+ * with shortcut keys. */
+int do_input(bool *meta_key, bool *func_key, bool *s_or_t, bool
+	*ran_func, bool *finished, bool allow_funcs)
+{
+    int input;
+	/* The character we read in. */
+    static int *kbinput = NULL;
+	/* The input buffer. */
+    static size_t kbinput_len = 0;
+	/* The length of the input buffer. */
+    bool cut_copy = FALSE;
+	/* Are we cutting or copying text? */
+    const sc *s;
+    bool have_shortcut;
+
+    *s_or_t = FALSE;
+    *ran_func = FALSE;
+    *finished = FALSE;
+
+    /* Read in a character. */
+    input = get_kbinput(edit, meta_key, func_key);
+
+#ifndef DISABLE_MOUSE
+    if (allow_funcs) {
+	/* If we got a mouse click and it was on a shortcut, read in the
+	 * shortcut character. */
+	if (*func_key && input == KEY_MOUSE) {
+	    if (do_mouse() == 1)
+		input = get_kbinput(edit, meta_key, func_key);
+	    else {
+		*meta_key = FALSE;
+		*func_key = FALSE;
+		input = ERR;
+	    }
+	}
+    }
+#endif
+
+    /* Check for a shortcut in the main list. */
+    s = get_shortcut(MMAIN, &input, meta_key, func_key);
+
+    /* 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 || *func_key) {
+	    statusbar(_("Unknown Command"));
+	    beep();
+	    *meta_key = FALSE;
+	    *func_key = FALSE;
+	    input = ERR;
+	}
+    }
+
+    if (allow_funcs) {
+	/* If we got a character, and it isn't a shortcut or toggle,
+	 * it's a normal text character.  Display the warning if we're
+	 * in view mode, or add the character to the input buffer if
+	 * we're not. */
+	if (input != ERR && !have_shortcut) {
+	    if (ISSET(VIEW_MODE))
+		print_view_warning();
+	    else {
+		kbinput_len++;
+		kbinput = (int *)nrealloc(kbinput, kbinput_len *
+			sizeof(int));
+		kbinput[kbinput_len - 1] = input;
+
+	    }
+	}
+
+	/* 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 the characters in the input buffer if it isn't
+	 * empty.  Note that it should 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 && (!have_shortcut || s == NULL || s->scfunc !=
+		do_verbatim_input))
+		wrap_reset();
+#endif
+
+	    if (kbinput != NULL) {
+		/* Display all the characters in the input buffer at
+		 * once, filtering out control characters. */
+		char *output = charalloc(kbinput_len + 1);
+		size_t i;
+
+		for (i = 0; i < kbinput_len; i++)
+		    output[i] = (char)kbinput[i];
+		output[i] = '\0';
+
+		do_output(output, kbinput_len, FALSE);
+
+		free(output);
+
+		/* Empty the input buffer. */
+		kbinput_len = 0;
+		free(kbinput);
+		kbinput = NULL;
+	    }
+	}
+
+	if (have_shortcut) {
+	    switch (input) {
+		/* Handle the normal edit window shortcuts, setting
+		 * ran_func to TRUE if we try to run their associated
+		 * functions and setting finished to TRUE to indicate
+		 * that we're done after running or trying to run their
+		 * associated functions. */
+		default:
+		    /* If the function associated with this shortcut is
+		     * cutting or copying text, indicate this. */
+		    if (s->scfunc == do_cut_text_void
+#ifndef NANO_TINY
+			|| s->scfunc == do_copy_text || s->scfunc ==
+			do_cut_till_end
+#endif
+			)
+			cut_copy = TRUE;
+
+		    if (s->scfunc != 0) {
+			const subnfunc *f = sctofunc((sc *) s);
+			*ran_func = TRUE;
+			if (ISSET(VIEW_MODE) && f && !f->viewok)
+			    print_view_warning();
+			else {
+#ifndef NANO_TINY
+			    if (s->scfunc == do_toggle_void)
+				do_toggle(s->toggle);
+			    else {
+#else
+			    {
+#endif
+				s->scfunc();
+#ifdef ENABLE_COLOR
+				if (f && !f->viewok && openfile->syntax != NULL
+					&& openfile->syntax->nmultis > 0) {
+				    reset_multis(openfile->current, FALSE);
+				}
+#endif
+				if (edit_refresh_needed) {
+#ifdef DEBUG
+	    			    fprintf(stderr, "running edit_refresh() as edit_refresh_needed is true\n");
+#endif
+				    edit_refresh();
+				    edit_refresh_needed = FALSE;
+				}
+
+			    }
+			}
+		    }
+		    *finished = TRUE;
+		    break;
+	    }
+	}
+    }
+
+    /* If we aren't cutting or copying text, blow away the text in the
+     * cutbuffer. */
+    if (!cut_copy)
+	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_x, mouse_y;
+    int retval = get_mouseinput(&mouse_x, &mouse_y, TRUE);
+
+    /* We can click on the edit window to move the cursor. */
+    if (retval == 0 && wmouse_trafo(edit, &mouse_y, &mouse_x, FALSE)) {
+	bool sameline;
+	    /* Did they click on the line with the cursor?  If they
+	     * clicked on the cursor, we set the mark. */
+	filestruct *current_save = openfile->current;
+	size_t current_x_save = openfile->current_x;
+	size_t pww_save = openfile->placewewant;
+
+	sameline = (mouse_y == openfile->current_y);
+
+#ifdef DEBUG
+	    fprintf(stderr, "mouse_y = %d, current_y = %d\n", mouse_y, openfile->current_y);
+#endif
+
+ 	if (ISSET(SOFTWRAP)) {
+	    int i = 0;
+	    for (openfile->current = openfile->edittop;
+		 openfile->current->next && i < mouse_y;
+		 openfile->current = openfile->current->next, i++) {
+		openfile->current_y = i;
+		i += strlenpt(openfile->current->data) / COLS;
+	    }
+
+#ifdef DEBUG
+	    fprintf(stderr, "do_mouse(): moving to current_y = %d, i %d\n", openfile->current_y, i);
+	    fprintf(stderr, "            openfile->current->data = \"%s\"\n", openfile->current->data);
+#endif
+
+	    if (i > mouse_y) {
+		openfile->current = openfile->current->prev;
+		openfile->current_x = actual_x(openfile->current->data, mouse_x + (mouse_y - openfile->current_y) * COLS);
+#ifdef DEBUG
+	    fprintf(stderr, "do_mouse(): i > mouse_y, mouse_x = %d, current_x to = %d\n", mouse_x, openfile->current_x);
+#endif
+	    } else {
+	        openfile->current_x = actual_x(openfile->current->data, mouse_x);
+#ifdef DEBUG
+	    fprintf(stderr, "do_mouse(): i <= mouse_y, mouse_x = %d, setting current_x to = %d\n", mouse_x, openfile->current_x);
+#endif
+	    }
+
+	    openfile->placewewant = xplustabs();
+
+	} else {
+	    /* Move to where the click occurred. */
+	    for (; openfile->current_y < mouse_y && openfile->current !=
+		   openfile->filebot; openfile->current_y++)
+		openfile->current = openfile->current->next;
+	    for (; openfile->current_y > mouse_y && openfile->current !=
+		   openfile->fileage; openfile->current_y--)
+		openfile->current = openfile->current->prev;
+
+	    openfile->current_x = actual_x(openfile->current->data,
+		get_page_start(xplustabs()) + mouse_x);
+
+	    openfile->placewewant = xplustabs();
+	}
+
+#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();
+#endif
+
+	edit_redraw(current_save, pww_save);
+    }
+
+    return retval;
+}
+#endif /* !DISABLE_MOUSE */
+
+#ifdef ENABLE_COLOR
+void alloc_multidata_if_needed(filestruct *fileptr)
+{
+    if (!fileptr->multidata)
+	fileptr->multidata = (short *) nmalloc(openfile->syntax->nmultis * sizeof(short));
+}
+
+/* Precalculate the multi-line start and end regex info so we can speed up
+   rendering (with any hope at all...) */
+void precalc_multicolorinfo(void)
+{
+#ifdef DEBUG
+	    fprintf(stderr, "entering precalc_multicolorinfo()\n");
+#endif
+    if (openfile->colorstrings != NULL && !ISSET(NO_COLOR_SYNTAX)) {
+	const colortype *tmpcolor = openfile->colorstrings;
+	regmatch_t startmatch, endmatch;
+	filestruct *fileptr, *endptr;
+	time_t last_check = time(NULL), cur_check = 0;
+
+	/* Let us get keypresses to see if the user is trying to
+	   start editing.  We may want to throw up a statusbar
+	   message before starting this later if it takes
+	   too long to do this routine.  For now silently
+	   abort if they hit a key */
+ 	nodelay(edit, FALSE);
+
+	for (; tmpcolor != NULL; tmpcolor = tmpcolor->next) {
+
+	    /* If it's not a multi-line regex, amscray */
+	    if (tmpcolor->end == NULL)
+		continue;
+#ifdef DEBUG
+	    fprintf(stderr, "working on color id %d\n", tmpcolor->id);
+#endif
+
+
+	    for (fileptr = openfile->fileage; fileptr != NULL; fileptr = fileptr->next) {
+		int startx = 0;
+		int nostart = 0;
+
+
+#ifdef DEBUG
+	    fprintf(stderr, "working on lineno %lu\n", (unsigned long) fileptr->lineno);
+#endif
+
+		alloc_multidata_if_needed(fileptr);
+
+		if ((cur_check = time(NULL)) - last_check > 1) {
+		    last_check = cur_check;
+		    if (wgetch(edit) != ERR)
+	   		goto precalc_cleanup;
+		}
+
+		while ((nostart = regexec(tmpcolor->start, &fileptr->data[startx], 1, &startmatch, 0))  == 0) {
+		    /* Look for end and start marking how many lines are encompassed
+		       whcih should speed up rendering later */
+		    startx += startmatch.rm_eo;
+#ifdef DEBUG
+		    fprintf(stderr, "match found at pos %d...", startx);
+#endif
+
+		    /* Look on this line first for end */
+		    if (regexec(tmpcolor->end, &fileptr->data[startx], 1, &endmatch, 0)  == 0) {
+			startx += endmatch.rm_eo;
+			fileptr->multidata[tmpcolor->id] |= CSTARTENDHERE;
+#ifdef DEBUG
+	    fprintf(stderr, "end found on this line\n");
+#endif
+			continue;
+		    }
+
+		    /* Nice, we didn't find the end regex on this line.  Let's start looking for it */
+		    for (endptr = fileptr->next; endptr != NULL; endptr = endptr->next) {
+
+#ifdef DEBUG
+	    fprintf(stderr, "advancing to line %lu to find end...\n", (unsigned long) endptr->lineno);
+#endif
+			/* Check for keyboard input  again */
+			if ((cur_check = time(NULL)) - last_check > 1) {
+			    last_check = cur_check;
+			    if (wgetch(edit) != ERR)
+		   		goto precalc_cleanup;
+			}
+			if (regexec(tmpcolor->end, endptr->data, 1, &endmatch, 0) == 0)
+			   break;
+		    }
+
+		    if (endptr == NULL) {
+#ifdef DEBUG
+	    		fprintf(stderr, "no end found, breaking out\n");
+#endif
+			break;
+		    }
+
+
+#ifdef DEBUG
+		    fprintf(stderr, "end found\n");
+#endif
+
+		    /* We found it, we found it, la la la la la.  Mark all the
+			lines in between and the ends properly */
+		    fileptr->multidata[tmpcolor->id] |= CENDAFTER;
+#ifdef DEBUG
+		    fprintf(stderr, "marking line %lu as CENDAFTER\n", (unsigned long) fileptr->lineno);
+#endif
+		    for (fileptr = fileptr->next; fileptr != endptr; fileptr = fileptr->next) {
+			alloc_multidata_if_needed(fileptr);
+			fileptr->multidata[tmpcolor->id] = CWHOLELINE;
+#ifdef DEBUG
+			fprintf(stderr, "marking intermediary line %lu as CWHOLELINE\n", (unsigned long) fileptr->lineno);
+#endif
+		    }
+		    alloc_multidata_if_needed(endptr);
+#ifdef DEBUG
+		    fprintf(stderr, "marking line %lu as BEGINBEFORE\n", (unsigned long) fileptr->lineno);
+#endif
+		    endptr->multidata[tmpcolor->id] |= CBEGINBEFORE;
+		    /* We should be able to skip all the way to the line of the match.
+			This may introduce more bugs but it's the Right Thing to do */
+		    fileptr = endptr;
+		    startx = endmatch.rm_eo;
+#ifdef DEBUG
+		    fprintf(stderr, "jumping to line %lu pos %d to continue\n", (unsigned long) endptr->lineno, startx);
+#endif
+		}
+		if (nostart && startx == 0) {
+#ifdef DEBUG
+		    fprintf(stderr, "no start found on line %lu, continuing\n", (unsigned long) fileptr->lineno);
+#endif
+		    fileptr->multidata[tmpcolor->id] = CNONE;
+		    continue;
+		}
+	    }
+	}
+    }
+precalc_cleanup:
+    nodelay(edit, FALSE);
+}
+#endif /* ENABLE_COLOR */
+
+/* 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, orig_lenpt, i = 0;
+    char *char_buf = charalloc(mb_cur_max());
+    int char_buf_len;
+
+    assert(openfile->current != NULL && openfile->current->data != NULL);
+
+    current_len = strlen(openfile->current->data);
+    if (ISSET(SOFTWRAP))
+	orig_lenpt = strlenpt(openfile->current->data);
+
+    while (i < output_len) {
+	/* If allow_cntrls is TRUE, convert nulls and newlines
+	 * properly. */
+	if (allow_cntrls) {
+	    /* Null to newline, if needed. */
+	    if (output[i] == '\0')
+		output[i] = '\n';
+	    /* Newline to Enter, if needed. */
+	    else if (output[i] == '\n') {
+		do_enter(FALSE);
+		i++;
+		continue;
+	    }
+	}
+
+	/* Interpret the next multibyte character. */
+	char_buf_len = parse_mbchar(output + i, char_buf, NULL);
+
+	i += char_buf_len;
+
+	/* If allow_cntrls is FALSE, filter out an ASCII control
+	 * character. */
+	if (!allow_cntrls && is_ascii_cntrl_char(*(output + i -
+		char_buf_len)))
+	    continue;
+
+	/* If the NO_NEWLINES flag isn't set, when a character is
+	 * added to the magicline, it means we need a new magicline. */
+	if (!ISSET(NO_NEWLINES) && openfile->filebot ==
+		openfile->current)
+	    new_magicline();
+
+	/* More dangerousness fun =) */
+	openfile->current->data = charealloc(openfile->current->data,
+		current_len + (char_buf_len * 2));
+
+	assert(openfile->current_x <= current_len);
+
+	charmove(openfile->current->data + openfile->current_x +
+		char_buf_len, openfile->current->data +
+		openfile->current_x, current_len - openfile->current_x +
+		char_buf_len);
+	strncpy(openfile->current->data + openfile->current_x, char_buf,
+		char_buf_len);
+	current_len += char_buf_len;
+	openfile->totsize++;
+	set_modified();
+
+#ifndef NANO_TINY
+	update_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_buf_len;
+#endif
+
+	openfile->current_x += char_buf_len;
+
+#ifndef DISABLE_WRAPPING
+	/* If we're wrapping text, we need to call edit_refresh(). */
+	if (!ISSET(NO_WRAP))
+	    if (do_wrap(openfile->current, FALSE))
+		edit_refresh_needed = TRUE;
+#endif
+
+#ifdef ENABLE_COLOR
+	/* If color syntaxes are available and turned on, we need to
+	 * call edit_refresh(). */
+	if (openfile->colorstrings != NULL && !ISSET(NO_COLOR_SYNTAX))
+	    edit_refresh_needed = TRUE;
+#endif
+    }
+
+    /* Well we might also need a full refresh if we've changed the 
+       line length to be a new multiple of COLS */
+    if (ISSET(SOFTWRAP) && edit_refresh_needed == FALSE)
+	if (strlenpt(openfile->current->data) / COLS  != orig_lenpt / COLS)
+	    edit_refresh_needed = TRUE;
+
+    free(char_buf);
+
+    openfile->placewewant = xplustabs();
+
+
+#ifdef ENABLE_COLOR
+    reset_multis(openfile->current, FALSE);
+#endif
+    if (edit_refresh_needed == TRUE) {
+	edit_refresh();
+	edit_refresh_needed = FALSE;
+    } else
+	update_line(openfile->current, openfile->current_x);
+}
+
+int main(int argc, char **argv)
+{
+    int optchr;
+    ssize_t startline = 1;
+	/* Line to try and start at. */
+    ssize_t startcol = 1;
+	/* Column to try and start at. */
+#ifndef DISABLE_WRAPJUSTIFY
+    bool fill_used = FALSE;
+	/* Was the fill option used? */
+#endif
+#ifdef ENABLE_MULTIBUFFER
+    bool old_multibuffer;
+	/* The old value of the multibuffer option, restored after we
+	 * load all files on the command line. */
+#endif
+#ifdef HAVE_GETOPT_LONG
+    const struct option long_options[] = {
+	{"help", 0, NULL, 'h'},
+	{"boldtext", 0, NULL, 'D'},
+#ifdef ENABLE_MULTIBUFFER
+	{"multibuffer", 0, NULL, 'F'},
+#endif
+#ifdef ENABLE_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'},
+#ifdef ENABLE_COLOR
+	{"syntax", 1, NULL, 'Y'},
+#endif
+	{"const", 0, NULL, 'c'},
+	{"rebinddelete", 0, NULL, 'd'},
+	{"nofollow", 0, NULL, 'l'},
+#ifndef DISABLE_MOUSE
+	{"mouse", 0, NULL, 'm'},
+#endif
+#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'},
+	{"historylog", 0, NULL, 'H'},
+	{"noconvert", 0, NULL, 'N'},
+	{"poslog", 0, NULL, 'P'},
+	{"smooth", 0, NULL, 'S'},
+	{"quickblank", 0, NULL, 'U'},
+	{"undo", 0, NULL, 'u'},
+	{"wordbounds", 0, NULL, 'W'},
+	{"autoindent", 0, NULL, 'i'},
+	{"cut", 0, NULL, 'k'},
+	{"softwrap", 0, NULL, '$'},
+#endif
+	{NULL, 0, NULL, 0}
+    };
+#endif
+
+#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(ENABLE_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
+
+    while ((optchr =
+#ifdef HAVE_GETOPT_LONG
+	getopt_long(argc, argv,
+		"h?ABC:DEFHIKLNOPQ:RST:UVWY:abcdefgijklmo:pqr:s:tuvwxz$",
+		long_options, NULL)
+#else
+	getopt(argc, argv,
+		"h?ABC:DEFHIKLNOPQ:RST:UVWY:abcdefgijklmo:pqr:s:tuvwxz$")
+#endif
+		) != -1) {
+	switch (optchr) {
+	    case 'a':
+	    case 'b':
+	    case 'e':
+	    case 'f':
+	    case 'g':
+	    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
+#ifdef ENABLE_MULTIBUFFER
+	    case 'F':
+		SET(MULTIBUFFER);
+		break;
+#endif
+#ifdef ENABLE_NANORC
+#ifndef NANO_TINY
+	    case 'H':
+		SET(HISTORYLOG);
+		break;
+#endif
+	    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 NANO_TINY
+	    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;
+#endif
+#ifdef ENABLE_COLOR
+	    case 'Y':
+		syntaxstr = mallocstrcpy(syntaxstr, optarg);
+		break;
+#endif
+	    case 'c':
+		SET(CONST_UPDATE);
+		break;
+	    case 'd':
+		SET(REBIND_DELETE);
+		break;
+#ifndef NANO_TINY
+	    case 'i':
+		SET(AUTOINDENT);
+		break;
+	    case 'k':
+		SET(CUT_TO_END);
+		break;
+#endif
+	    case 'l':
+		SET(NOFOLLOW_SYMLINKS);
+		break;
+#ifndef DISABLE_MOUSE
+	    case 'm':
+		SET(USE_MOUSE);
+		break;
+#endif
+#ifndef DISABLE_OPERATINGDIR
+	    case 'o':
+		operating_dir = mallocstrcpy(operating_dir, optarg);
+		break;
+#endif
+	    case 'p':
+		SET(PRESERVE);
+		break;
+	    case 'q':
+		SET(QUIET);
+		break;
+#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;
+		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(UNDOABLE);
+		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 option wins, */
+		fill_used = FALSE;
+
+		break;
+#endif
+	    case 'x':
+		SET(NO_HELP);
+		break;
+	    case 'z':
+		SET(SUSPEND);
+		break;
+#ifndef NANO_TINY
+	    case '$':
+		SET(SOFTWRAP);
+		break;
+#endif
+	    default:
+		usage();
+	}
+    }
+
+    /* If the executable filename starts with 'r', enable restricted
+     * mode. */
+    if (*(tail(argv[0])) == 'r')
+	SET(RESTRICTED);
+
+    /* If we're using restricted mode, disable suspending, backups, and
+     * reading rcfiles, 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);
+#ifdef ENABLE_NANORC
+	no_rcfiles = TRUE;
+#endif
+    }
+
+
+    /* Set up the shortcut lists.
+       Need to do this before the rcfile */
+    shortcut_init(FALSE);
+
+/* 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. */
+#ifdef ENABLE_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;
+#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;
+#endif
+#ifndef DISABLE_JUSTIFY
+	quotestr = NULL;
+#endif
+#ifndef DISABLE_SPELLER
+	alt_speller = NULL;
+#endif
+
+	do_rcfile();
+
+#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;
+	}
+#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 /* ENABLE_NANORC */
+
+#ifndef DISABLE_WRAPPING
+    /* Overwrite an rcfile "set nowrap" or --disable-wrapping-as-root
+       if a --fill option was given on the command line. */ 
+    if (fill_used)
+	UNSET(NO_WRAP);
+#endif
+
+    /* If we're using bold text instead of reverse video text, set it up
+     * now. */
+    if (ISSET(BOLD_TEXT))
+	reverse_attr = A_BOLD;
+
+#ifndef NANO_TINY
+    /* Set up the search/replace history. */
+    history_init();
+#ifdef ENABLE_NANORC
+    if (!no_rcfiles) {
+	if (ISSET(HISTORYLOG) || ISSET(POS_HISTORY)) {
+	    if (check_dotnano() == 0) {
+		UNSET(HISTORYLOG);
+		UNSET(POS_HISTORY);
+	    }
+	}
+	if (ISSET(HISTORYLOG))
+	    load_history();
+	if (ISSET(POS_HISTORY))
+	    load_poshistory();
+    }
+#endif /* ENABLE_NANORC */
+#endif /* NANO_TINY */
+
+#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,
+#ifdef HAVE_REGEX_H
+		"^([ \t]*[#:>|}])+"
+#else
+		"> "
+#endif
+		);
+#ifdef HAVE_REGEX_H
+    quoterc = regcomp(&quotereg, quotestr, REG_EXTENDED);
+
+    if (quoterc == 0) {
+	/* We no longer need quotestr, just quotereg. */
+	free(quotestr);
+	quotestr = NULL;
+    } else {
+	size_t size = regerror(quoterc, &quotereg, NULL, 0);
+
+	quoteerr = charalloc(size);
+	regerror(quoterc, &quotereg, quoteerr, size);
+    }
+#else
+    quotelen = strlen(quotestr);
+#endif /* !HAVE_REGEX_H */
+#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, "(<[{)>]}");
+#endif
+
+#if !defined(NANO_TINY) && defined(ENABLE_NANORC)
+    /* If whitespace wasn't specified, set its default value. */
+    if (whitespace == NULL) {
+	whitespace = mallocstrcpy(NULL, "  ");
+	whitespace_len[0] = 1;
+	whitespace_len[1] = 1;
+    }
+#endif
+
+    /* If tabsize wasn't specified, set its default value. */
+    if (tabsize == -1)
+	tabsize = WIDTH_OF_TAB;
+
+    /* Back up the old terminal settings so that they can be restored. */
+    tcgetattr(0, &oldterm);
+
+    /* Initialize curses mode.  If this fails, get out. */
+    if (initscr() == NULL)
+	exit(1);
+
+    /* Set up the terminal state. */
+    terminal_init();
+
+    /* Turn the cursor on for sure. */
+    curs_set(1);
+
+#ifdef DEBUG
+    fprintf(stderr, "Main: set up windows\n");
+#endif
+
+    /* Initialize all the windows based on the current screen
+     * dimensions. */
+    window_init();
+
+    /* Set up the signal handlers. */
+    signal_init();
+
+#ifndef DISABLE_MOUSE
+    /* Initialize mouse support. */
+    mouse_init();
+#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] == '+') {
+	parse_line_column(&argv[optind][1], &startline, &startcol);
+	optind++;
+    }
+
+    if (optind < argc && !strcmp(argv[optind], "-")) {
+	stdin_pager();
+	set_modified();
+	optind++;
+    }
+
+#ifdef ENABLE_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 = 1, icol = 1;
+
+	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] == '+' && iline == 1 &&
+		icol == 1)
+		parse_line_column(&argv[i][1], &iline, &icol);
+	    else {
+		open_buffer(argv[i], FALSE);
+
+		if (iline > 1 || icol > 1) {
+		    do_gotolinecolumn(iline, icol, FALSE, FALSE, FALSE,
+			FALSE);
+		    iline = 1;
+		    icol = 1;
+		}
+#ifndef NANO_TINY
+                  else {
+		    /* See if we have a POS history to use if we haven't overridden it */
+		    ssize_t savedposline, savedposcol;
+		    if (check_poshistory(argv[i], &savedposline, &savedposcol))
+			do_gotolinecolumn(savedposline, savedposcol, FALSE, FALSE, FALSE,
+			FALSE);
+		}
+#endif /* NANO_TINY */
+	    }
+	}
+    }
+#endif
+
+    /* Read the first file on the command line into either the current
+     * buffer or a new buffer, depending on whether multibuffer mode is
+     * enabled. */
+    if (optind < argc)
+	open_buffer(argv[optind], FALSE);
+
+    /* We didn't open any files if all the command line arguments were
+     * invalid files like directories or if there were no command line
+     * arguments given.  In this case, we have to load a blank buffer.
+     * Also, we unset view mode to allow editing. */
+    if (openfile == NULL) {
+	open_buffer("", FALSE);
+	UNSET(VIEW_MODE);
+    }
+
+#ifdef ENABLE_MULTIBUFFER
+    if (!old_multibuffer)
+	UNSET(MULTIBUFFER);
+#endif
+
+#ifdef DEBUG
+    fprintf(stderr, "Main: top and bottom win\n");
+#endif
+
+#ifdef ENABLE_COLOR
+    if (openfile->syntax && openfile->syntax->nmultis > 0)
+	precalc_multicolorinfo();
+#endif
+
+    if (startline > 1 || startcol > 1)
+	do_gotolinecolumn(startline, startcol, FALSE, FALSE, FALSE,
+		FALSE);
+# ifndef NANO_TINY
+    else {
+	/* See if we have a POS history to use if we haven't overridden it */
+	ssize_t savedposline, savedposcol;
+	if (check_poshistory(argv[optind], &savedposline, &savedposcol))
+	    do_gotolinecolumn(savedposline, savedposcol, FALSE, FALSE, FALSE, FALSE);
+    }
+#endif /* NANO_TINY */
+
+    display_main_list();
+
+    display_buffer();
+
+    while (TRUE) {
+	bool meta_key, func_key, s_or_t, ran_func, finished;
+
+	/* Make sure the cursor is in the edit window. */
+	reset_cursor();
+	wnoutrefresh(edit);
+
+#ifndef NANO_TINY
+	if (!jump_buf_main) {
+	    /* If we haven't already, we're going to set jump_buf so
+	     * that we return here after a SIGWINCH.  Indicate this. */
+	    jump_buf_main = TRUE;
+
+	    /* Return here after a SIGWINCH. */
+	    sigsetjmp(jump_buf, 1);
+	}
+#endif
+
+	/* Just in case we were at the statusbar prompt, make sure the
+	 * statusbar cursor position is reset. */
+	do_prompt_abort();
+
+	/* If constant cursor position display is on, and there are no
+	 * keys waiting in the input buffer, display the current cursor
+	 * position on the statusbar. */
+	if (ISSET(CONST_UPDATE) && get_key_buffer_len() == 0)
+	    do_cursorpos(TRUE);
+
+        currmenu = MMAIN;
+
+	/* Read in and interpret characters. */
+	do_input(&meta_key, &func_key, &s_or_t, &ran_func, &finished,
+		TRUE);
+    }
+
+    /* We should never get here. */
+    assert(FALSE);
+}
+
diff --git a/src/nano.h b/src/nano.h
new file mode 100644
index 0000000..b19d195
--- /dev/null
+++ b/src/nano.h
@@ -0,0 +1,794 @@
+/* $Id: nano.h 4535 2011-02-26 14:22:37Z astyanax $ */
+/**************************************************************************
+ *   nano.h                                                               *
+ *                                                                        *
+ *   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.                                                     *
+ *                                                                        *
+ **************************************************************************/
+
+#ifndef NANO_H
+#define NANO_H 1
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef NEED_XOPEN_SOURCE_EXTENDED
+#ifndef _XOPEN_SOURCE_EXTENDED
+#define _XOPEN_SOURCE_EXTENDED 1
+#endif /* _XOPEN_SOURCE_EXTENDED */
+#endif /* NEED_XOPEN_SOURCE_EXTENDED */
+
+#ifdef __TANDEM
+/* Tandem NonStop Kernel support. */
+#include <floss.h>
+#define NANO_ROOT_UID 65535
+#else
+#define NANO_ROOT_UID 0
+#endif
+
+#ifdef HAVE_LIMITS_H
+#include <limits.h>
+#endif
+
+#ifdef HAVE_SYS_PARAM_H
+#include <sys/param.h>
+#endif
+
+#ifdef HAVE_STDARG_H
+#include <stdarg.h>
+#endif
+
+/* Suppress warnings for __attribute__((warn_unused_result)) */
+#define IGNORE_CALL_RESULT(call) do { if (call) {} } while(0)
+
+/* Macros for flags. */
+#define FLAGOFF(flag) ((flag) / (sizeof(unsigned) * 8))
+#define FLAGMASK(flag) (1 << ((flag) % (sizeof(unsigned) * 8)))
+#define FLAGS(flag) flags[FLAGOFF(flag)]
+#define SET(flag) FLAGS(flag) |= FLAGMASK(flag)
+#define UNSET(flag) FLAGS(flag) &= ~FLAGMASK(flag)
+#define ISSET(flag) ((FLAGS(flag) & FLAGMASK(flag)) != 0)
+#define TOGGLE(flag) FLAGS(flag) ^= FLAGMASK(flag)
+
+/* Macros for character allocation and more. */
+#define charalloc(howmuch) (char *)nmalloc((howmuch) * sizeof(char))
+#define charealloc(ptr, howmuch) (char *)nrealloc(ptr, (howmuch) * sizeof(char))
+#define charmove(dest, src, n) memmove(dest, src, (n) * sizeof(char))
+#define charset(dest, src, n) memset(dest, src, (n) * sizeof(char))
+
+/* Set a default value for PATH_MAX if there isn't one. */
+#ifndef PATH_MAX
+#define PATH_MAX 4096
+#endif
+
+#ifdef USE_SLANG
+/* Slang support. */
+#include <slcurses.h>
+/* Slang curses emulation brain damage, part 3: Slang doesn't define the
+ * curses equivalents of the Insert or Delete keys. */
+#define KEY_DC SL_KEY_DELETE
+#define KEY_IC SL_KEY_IC
+/* Ncurses support. */
+#elif defined(HAVE_NCURSES_H)
+#include <ncurses.h>
+#else
+/* Curses support. */
+#include <curses.h>
+#endif /* CURSES_H */
+
+#ifdef ENABLE_NLS
+/* Native language support. */
+#ifdef HAVE_LIBINTL_H
+#include <libintl.h>
+#endif
+#define _(string) gettext(string)
+#define P_(singular, plural, number) ngettext(singular, plural, number)
+#else
+#define _(string) (string)
+#define P_(singular, plural, number) (number == 1 ? singular : plural)
+#endif
+#define gettext_noop(string) (string)
+#define N_(string) gettext_noop(string)
+	/* Mark a string that will be sent to gettext() later. */
+
+#include <stddef.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#ifdef HAVE_REGEX_H
+#include <regex.h>
+#endif
+#ifndef NANO_TINY
+#include <setjmp.h>
+#endif
+#include <assert.h>
+
+/* If no vsnprintf(), use the version from glib 2.x. */
+#ifndef HAVE_VSNPRINTF
+#include <glib.h>
+#define vsnprintf g_vsnprintf
+#endif
+
+/* If no isblank(), iswblank(), strcasecmp(), strncasecmp(),
+ * strcasestr(), strnlen(), getdelim(), or getline(), use the versions
+ * we have. */
+#ifndef HAVE_ISBLANK
+#define isblank nisblank
+#endif
+#ifndef HAVE_ISWBLANK
+#define iswblank niswblank
+#endif
+#ifndef HAVE_STRCASECMP
+#define strcasecmp nstrcasecmp
+#endif
+#ifndef HAVE_STRNCASECMP
+#define strncasecmp nstrncasecmp
+#endif
+#ifndef HAVE_STRCASESTR
+#define strcasestr nstrcasestr
+#endif
+#ifndef HAVE_STRNLEN
+#define strnlen nstrnlen
+#endif
+#ifndef HAVE_GETDELIM
+#define getdelim ngetdelim
+#endif
+#ifndef HAVE_GETLINE
+#define getline ngetline
+#endif
+
+/* If we aren't using ncurses with mouse support, turn the mouse support
+ * off, as it's useless then. */
+#ifndef NCURSES_MOUSE_VERSION
+#define DISABLE_MOUSE 1
+#endif
+
+#if defined(DISABLE_WRAPPING) && defined(DISABLE_JUSTIFY)
+#define DISABLE_WRAPJUSTIFY 1
+#endif
+
+/* Enumeration types. */
+typedef enum {
+    NIX_FILE, DOS_FILE, MAC_FILE
+} file_format;
+
+typedef enum {
+    OVERWRITE, APPEND, PREPEND
+} append_type;
+
+typedef enum {
+    UP_DIR, DOWN_DIR
+} scroll_dir;
+
+typedef enum {
+    CENTER, NONE
+} update_type;
+
+typedef enum {
+    CONTROL, META, FKEY, RAWINPUT
+}  function_type;
+
+typedef enum {
+    ADD, DEL, REPLACE, SPLIT, UNSPLIT, CUT, UNCUT, ENTER, INSERT, OTHER
+} undo_type;
+
+#ifdef ENABLE_COLOR
+typedef struct colortype {
+    short fg;
+	/* This syntax's foreground color. */
+    short bg;
+	/* This syntax's background color. */
+    bool bright;
+	/* Is this color A_BOLD? */
+    bool icase;
+	/* Is this regex string case insensitive? */
+    int pairnum;
+	/* The color pair number used for this foreground color and
+	 * background color. */
+    char *start_regex;
+	/* The start (or all) of the regex string. */
+    regex_t *start;
+	/* The compiled start (or all) of the regex string. */
+    char *end_regex;
+	/* The end (if any) of the regex string. */
+    regex_t *end;
+	/* The compiled end (if any) of the regex string. */
+    struct colortype *next;
+	/* Next set of colors. */
+     int id;
+	/* basic id for assigning to lines later */
+} colortype;
+
+typedef struct exttype {
+    char *ext_regex;
+	/* The extensions that match this syntax. */
+    regex_t *ext;
+	/* The compiled extensions that match this syntax. */
+    struct exttype *next;
+	/* Next set of extensions. */
+} exttype;
+
+typedef struct syntaxtype {
+    char *desc;
+	/* The name of this syntax. */
+    exttype *extensions;
+	/* The list of extensions that this syntax applies to. */
+    exttype *headers;
+	/* Regexes to match on the 'header' (1st line) of the file */
+    exttype *magics;
+	/* Regexes to match libmagic results */
+    colortype *color;
+	/* The colors used in this syntax. */
+    int nmultis;
+	/* How many multi line strings this syntax has */
+    struct syntaxtype *next;
+	/* Next syntax. */
+} syntaxtype;
+
+#define CNONE 		(1<<1)
+	/* Yay, regex doesn't apply to this line at all! */
+#define CBEGINBEFORE 	(1<<2)
+	/* regex starts on an earlier line, ends on this one */
+#define CENDAFTER 	(1<<3)
+	/* regex sraers on this line and ends on a later one */
+#define CWHOLELINE 	(1<<4)
+	/* whole line engulfed by the regex  start < me, end > me */
+#define CSTARTENDHERE 	(1<<5)
+	/* regex starts and ends within this line */
+#define CWTF		(1<<6)
+	/* Something else */
+
+#endif /* ENABLE_COLOR */
+
+
+/* Structure types. */
+typedef struct filestruct {
+    char *data;
+	/* The text of this line. */
+    ssize_t lineno;
+	/* The number of this line. */
+    struct filestruct *next;
+	/* Next node. */
+    struct filestruct *prev;
+	/* Previous node. */
+#ifdef ENABLE_COLOR
+    short *multidata;		/* Array of which multi-line regexes apply to this line */
+#endif
+} filestruct;
+
+typedef struct partition {
+    filestruct *fileage;
+	/* The top line of this portion of the file. */
+    filestruct *top_prev;
+	/* The line before the top line of this portion of the file. */
+    char *top_data;
+	/* The text before the beginning of the top line of this portion
+	 * of the file. */
+    filestruct *filebot;
+	/* The bottom line of this portion of the file. */
+    filestruct *bot_next;
+	/* The line after the bottom line of this portion of the
+	 * file. */
+    char *bot_data;
+	/* The text after the end of the bottom line of this portion of
+	 * the file. */
+} partition;
+
+#ifndef NANO_TINY
+typedef struct undo {
+    ssize_t lineno;
+    undo_type type;
+	/* What type of undo was this */
+    int begin;
+	/* Where did this  action begin or end */
+    char *strdata;
+	/* String type data we will use for ccopying the affected line back */
+    char *strdata2;
+	/* Sigh, need this too it looks like */
+    int xflags;
+	/* Some flag data we need */
+
+    /* Cut specific stuff we need */
+    filestruct *cutbuffer;
+	/* Copy of the cutbuffer */
+    filestruct *cutbottom;
+	/* Copy of cutbottom */
+    bool mark_set;
+	/* was the marker set when we cut */
+    bool to_end;
+	/* was this a cut to end */
+    ssize_t mark_begin_lineno;
+	/* copy copy copy */
+    ssize_t mark_begin_x;
+	/* Another shadow variable */
+    struct undo *next;
+} undo;
+
+
+typedef struct poshiststruct {
+    char *filename;
+        /* The file. */
+    ssize_t lineno;
+	/* Line number we left off on */
+    ssize_t xno;
+	/* x position in the file we left off on */
+    struct poshiststruct *next;
+} poshiststruct;
+#endif /* NANO_TINY */
+
+
+typedef struct openfilestruct {
+    char *filename;
+	/* The current file's name. */
+    filestruct *fileage;
+	/* The current file's first line. */
+    filestruct *filebot;
+	/* The current file's last line. */
+    filestruct *edittop;
+	/* The current top of the edit window. */
+    filestruct *current;
+	/* The current file's current line. */
+    size_t totsize;
+	/* The current file's total number of characters. */
+    size_t current_x;
+	/* The current file's x-coordinate position. */
+    size_t placewewant;
+	/* The current file's place we want. */
+    ssize_t current_y;
+	/* The current file's y-coordinate position. */
+    bool modified;
+	/* Whether the current file has been modified. */
+#ifndef NANO_TINY
+    bool mark_set;
+	/* Whether the mark is on in the current file. */
+    filestruct *mark_begin;
+	/* The current file's beginning marked line, if any. */
+    size_t mark_begin_x;
+	/* The current file's beginning marked line's x-coordinate
+	 * position, if any. */
+    file_format fmt;
+	/* The current file's format. */
+    struct stat *current_stat;
+	/* The current file's stat. */
+    undo *undotop;
+	/* Top of the undo list */
+    undo *current_undo;
+	/* The current (i.e. n ext) level of undo */
+    undo_type last_action;
+#endif
+#ifdef ENABLE_COLOR
+    syntaxtype *syntax;
+	/* The  syntax struct for this file, if any */
+    colortype *colorstrings;
+	/* The current file's associated colors. */
+#endif
+    struct openfilestruct *next;
+	/* Next node. */
+    struct openfilestruct *prev;
+	/* Previous node. */
+} openfilestruct;
+
+typedef struct shortcut {
+    const char *desc;
+	/* The function's description, e.g. "Page Up". */
+#ifndef DISABLE_HELP
+    const char *help;
+	/* The help file entry text for this function. */
+    bool blank_after;
+	/* Whether there should be a blank line after the help entry
+	 * text for this function. */
+#endif
+    /* Note: Key values that aren't used should be set to
+     * NANO_NO_KEY. */
+    int ctrlval;
+	/* The special sentinel key or control key we want bound, if
+	 * any. */
+    int metaval;
+	/* The meta key we want bound, if any. */
+    int funcval;
+	/* The function key we want bound, if any. */
+    int miscval;
+	/* The other meta key we want bound, if any. */
+    bool viewok;
+	/* Is this function allowed when in view mode? */
+    void (*func)(void);
+	/* The function to call when we get this key. */
+    struct shortcut *next;
+	/* Next shortcut. */
+} shortcut;
+
+#ifdef ENABLE_NANORC
+typedef struct rcoption {
+   const char *name;
+	/* The name of the rcfile option. */
+   long flag;
+	/* The flag associated with it, if any. */
+} rcoption;
+
+#endif
+
+typedef struct sc {
+    char *keystr;
+	/* The shortcut key for a function, ASCII version */
+    function_type type;
+        /* What kind of function key is it for convenience later */
+    int seq;
+        /* The actual sequence to check on the the type is determined */
+    int menu;
+        /* What list does this apply to */
+    void (*scfunc)(void);
+        /* The function we're going to run */
+    int toggle;
+        /* If a toggle, what we're toggling */
+    bool execute;
+	/* Whether to execute the function in question or just return
+	   so the sequence can be caught by the calling code */
+    struct sc *next;
+        /* Next in the list */
+} sc;
+
+typedef struct subnfunc {
+    void (*scfunc)(void);
+	/* What function is this */
+    int menus;
+	/* In what menus does this function applu */
+    const char *desc;
+	/* The function's description, e.g. "Page Up". */
+#ifndef DISABLE_HELP
+    const char *help;
+	/* The help file entry text for this function. */
+    bool blank_after;
+	/* Whether there should be a blank line after the help entry
+	 * text for this function. */
+#endif
+    bool viewok;
+        /* Is this function allowed when in view mode? */
+    long toggle;
+	/* If this is a toggle, if nonzero what toggle to set */
+    struct subnfunc *next;
+	/* next item in the list */
+} subnfunc;
+
+
+/* Enumeration to be used in flags table. See FLAGBIT and FLAGOFF 
+ * definitions. */
+enum
+{
+    DONTUSE,
+    CASE_SENSITIVE,
+    CONST_UPDATE,
+    NO_HELP,
+    NOFOLLOW_SYMLINKS,
+    SUSPEND,
+    NO_WRAP,
+    AUTOINDENT,
+    VIEW_MODE,
+    USE_MOUSE,
+    USE_REGEXP,
+    TEMP_FILE,
+    CUT_TO_END,
+    BACKWARDS_SEARCH,
+    MULTIBUFFER,
+    SMOOTH_SCROLL,
+    REBIND_DELETE,
+    REBIND_KEYPAD,
+    NO_CONVERT,
+    BACKUP_FILE,
+    INSECURE_BACKUP,
+    NO_COLOR_SYNTAX,
+    PRESERVE,
+    HISTORYLOG,
+    RESTRICTED,
+    SMART_HOME,
+    WHITESPACE_DISPLAY,
+    MORE_SPACE,
+    TABS_TO_SPACES,
+    QUICK_BLANK,
+    WORD_BOUNDS,
+    NO_NEWLINES,
+    BOLD_TEXT,
+    QUIET,
+    UNDOABLE,
+    SOFTWRAP,
+    POS_HISTORY
+};
+
+/* Flags for which menus in which a given function should be present */
+#define MMAIN				(1<<0)
+#define	MWHEREIS			(1<<1)
+#define	MREPLACE			(1<<2)
+#define	MREPLACE2			(1<<3)
+#define	MGOTOLINE			(1<<4)
+#define	MWRITEFILE			(1<<5)
+#define	MINSERTFILE			(1<<6)
+#define	MEXTCMD				(1<<7)
+#define	MHELP				(1<<8)
+#define	MSPELL				(1<<9)
+#define	MBROWSER			(1<<10)
+#define	MWHEREISFILE			(1<<11)
+#define MGOTODIR			(1<<12)
+#define MYESNO				(1<<13)
+/* This really isnt all but close enough */
+#define	MALL				(MMAIN|MWHEREIS|MREPLACE|MREPLACE2|MGOTOLINE|MWRITEFILE|MINSERTFILE|MEXTCMD|MSPELL|MBROWSER|MWHEREISFILE|MGOTODIR|MHELP)
+
+/* Control key sequences.  Changing these would be very, very bad. */
+#define NANO_CONTROL_SPACE 0
+#define NANO_CONTROL_A 1
+#define NANO_CONTROL_B 2
+#define NANO_CONTROL_C 3
+#define NANO_CONTROL_D 4
+#define NANO_CONTROL_E 5
+#define NANO_CONTROL_F 6
+#define NANO_CONTROL_G 7
+#define NANO_CONTROL_H 8
+#define NANO_CONTROL_I 9
+#define NANO_CONTROL_J 10
+#define NANO_CONTROL_K 11
+#define NANO_CONTROL_L 12
+#define NANO_CONTROL_M 13
+#define NANO_CONTROL_N 14
+#define NANO_CONTROL_O 15
+#define NANO_CONTROL_P 16
+#define NANO_CONTROL_Q 17
+#define NANO_CONTROL_R 18
+#define NANO_CONTROL_S 19
+#define NANO_CONTROL_T 20
+#define NANO_CONTROL_U 21
+#define NANO_CONTROL_V 22
+#define NANO_CONTROL_W 23
+#define NANO_CONTROL_X 24
+#define NANO_CONTROL_Y 25
+#define NANO_CONTROL_Z 26
+#define NANO_CONTROL_3 27
+#define NANO_CONTROL_4 28
+#define NANO_CONTROL_5 29
+#define NANO_CONTROL_6 30
+#define NANO_CONTROL_7 31
+#define NANO_CONTROL_8 127
+
+/* Meta key sequences. */
+#define NANO_META_SPACE ' '
+#define NANO_META_LPARENTHESIS '('
+#define NANO_META_RPARENTHESIS ')'
+#define NANO_META_PLUS '+'
+#define NANO_META_COMMA ','
+#define NANO_META_MINUS '-'
+#define NANO_META_PERIOD '.'
+#define NANO_META_SLASH '/'
+#define NANO_META_0 '0'
+#define NANO_META_6 '6'
+#define NANO_META_9 '9'
+#define NANO_META_LCARET '<'
+#define NANO_META_EQUALS '='
+#define NANO_META_RCARET '>'
+#define NANO_META_QUESTION '?'
+#define NANO_META_BACKSLASH '\\'
+#define NANO_META_RBRACKET ']'
+#define NANO_META_CARET '^'
+#define NANO_META_UNDERSCORE '_'
+#define NANO_META_A 'a'
+#define NANO_META_B 'b'
+#define NANO_META_C 'c'
+#define NANO_META_D 'd'
+#define NANO_META_E 'e'
+#define NANO_META_F 'f'
+#define NANO_META_G 'g'
+#define NANO_META_H 'h'
+#define NANO_META_I 'i'
+#define NANO_META_J 'j'
+#define NANO_META_K 'k'
+#define NANO_META_L 'l'
+#define NANO_META_M 'm'
+#define NANO_META_N 'n'
+#define NANO_META_O 'o'
+#define NANO_META_P 'p'
+#define NANO_META_Q 'q'
+#define NANO_META_R 'r'
+#define NANO_META_S 's'
+#define NANO_META_T 't'
+#define NANO_META_U 'u'
+#define NANO_META_V 'v'
+#define NANO_META_W 'w'
+#define NANO_META_X 'x'
+#define NANO_META_Y 'y'
+#define NANO_META_Z 'z'
+#define NANO_META_LCURLYBRACKET '{'
+#define NANO_META_PIPE '|'
+#define NANO_META_RCURLYBRACKET '}'
+
+/* Some semi-changeable keybindings; don't play with these unless you're
+ * sure you know what you're doing.  Assume ERR is defined as -1. */
+
+/* No key at all. */
+#define NANO_NO_KEY			-2
+
+/* Normal keys. */
+#define NANO_XON_KEY			NANO_CONTROL_Q
+#define NANO_XOFF_KEY			NANO_CONTROL_S
+#define NANO_CANCEL_KEY			NANO_CONTROL_C
+#define NANO_EXIT_KEY			NANO_CONTROL_X
+#define NANO_EXIT_FKEY			KEY_F(2)
+#define NANO_INSERTFILE_KEY		NANO_CONTROL_R
+#define NANO_INSERTFILE_FKEY		KEY_F(5)
+#define NANO_TOOTHERINSERT_KEY		NANO_CONTROL_X
+#define NANO_WRITEOUT_KEY		NANO_CONTROL_O
+#define NANO_WRITEOUT_FKEY		KEY_F(3)
+#define NANO_GOTOLINE_KEY		NANO_CONTROL_7
+#define NANO_GOTOLINE_FKEY		KEY_F(13)
+#define NANO_GOTOLINE_METAKEY		NANO_META_G
+#define NANO_GOTODIR_KEY		NANO_CONTROL_7
+#define NANO_GOTODIR_FKEY		KEY_F(13)
+#define NANO_GOTODIR_METAKEY		NANO_META_G
+#define NANO_TOGOTOLINE_KEY		NANO_CONTROL_T
+#define NANO_HELP_KEY			NANO_CONTROL_G
+#define NANO_HELP_FKEY			KEY_F(1)
+#define NANO_WHEREIS_KEY		NANO_CONTROL_W
+#define NANO_WHEREIS_FKEY		KEY_F(6)
+#define NANO_WHEREIS_NEXT_KEY		NANO_META_W
+#define NANO_WHEREIS_NEXT_FKEY		KEY_F(16)
+#define NANO_TOOTHERWHEREIS_KEY		NANO_CONTROL_T
+#define NANO_REGEXP_KEY			NANO_META_R
+#define NANO_REPLACE_KEY		NANO_CONTROL_4
+#define NANO_REPLACE_FKEY		KEY_F(14)
+#define NANO_REPLACE_METAKEY		NANO_META_R
+#define NANO_TOOTHERSEARCH_KEY		NANO_CONTROL_R
+#define NANO_PREVPAGE_KEY		NANO_CONTROL_Y
+#define NANO_PREVPAGE_FKEY		KEY_F(7)
+#define NANO_NEXTPAGE_KEY		NANO_CONTROL_V
+#define NANO_NEXTPAGE_FKEY		KEY_F(8)
+#define NANO_CUT_KEY			NANO_CONTROL_K
+#define NANO_CUT_FKEY			KEY_F(9)
+#define NANO_COPY_KEY			NANO_META_CARET
+#define NANO_COPY_METAKEY		NANO_META_6
+#define NANO_UNCUT_KEY			NANO_CONTROL_U
+#define NANO_UNCUT_FKEY			KEY_F(10)
+#define NANO_CURSORPOS_KEY		NANO_CONTROL_C
+#define NANO_CURSORPOS_FKEY		KEY_F(11)
+#define NANO_SPELL_KEY			NANO_CONTROL_T
+#define NANO_SPELL_FKEY			KEY_F(12)
+#define NANO_FIRSTLINE_KEY		NANO_PREVPAGE_KEY
+#define NANO_FIRSTLINE_FKEY		NANO_PREVPAGE_FKEY
+#define NANO_FIRSTLINE_METAKEY		NANO_META_BACKSLASH
+#define NANO_FIRSTLINE_METAKEY2		NANO_META_PIPE
+#define NANO_FIRSTFILE_KEY		NANO_FIRSTLINE_KEY
+#define NANO_FIRSTFILE_FKEY		NANO_FIRSTLINE_FKEY
+#define NANO_FIRSTFILE_METAKEY		NANO_FIRSTLINE_METAKEY
+#define NANO_FIRSTFILE_METAKEY2		NANO_FIRSTLINE_METAKEY2
+#define NANO_LASTLINE_KEY		NANO_NEXTPAGE_KEY
+#define NANO_LASTLINE_FKEY		NANO_NEXTPAGE_FKEY
+#define NANO_LASTLINE_METAKEY		NANO_META_SLASH
+#define NANO_LASTLINE_METAKEY2		NANO_META_QUESTION
+#define NANO_LASTFILE_KEY		NANO_LASTLINE_KEY
+#define NANO_LASTFILE_FKEY		NANO_LASTLINE_FKEY
+#define NANO_LASTFILE_METAKEY		NANO_LASTLINE_METAKEY
+#define NANO_LASTFILE_METAKEY2		NANO_LASTLINE_METAKEY2
+#define NANO_REFRESH_KEY		NANO_CONTROL_L
+#define NANO_JUSTIFY_KEY		NANO_CONTROL_J
+#define NANO_JUSTIFY_FKEY		KEY_F(4)
+#define NANO_UNJUSTIFY_KEY		NANO_UNCUT_KEY
+#define NANO_UNJUSTIFY_FKEY		NANO_UNCUT_FKEY
+#define NANO_PREVLINE_KEY		NANO_CONTROL_P
+#define NANO_NEXTLINE_KEY		NANO_CONTROL_N
+#define NANO_FORWARD_KEY		NANO_CONTROL_F
+#define NANO_BACK_KEY			NANO_CONTROL_B
+#define NANO_MARK_KEY			NANO_CONTROL_6
+#define NANO_MARK_METAKEY		NANO_META_A
+#define NANO_MARK_FKEY			KEY_F(15)
+#define NANO_HOME_KEY			NANO_CONTROL_A
+#define NANO_END_KEY			NANO_CONTROL_E
+#define NANO_DELETE_KEY			NANO_CONTROL_D
+#define NANO_BACKSPACE_KEY		NANO_CONTROL_H
+#define NANO_TAB_KEY			NANO_CONTROL_I
+#define NANO_INDENT_KEY			NANO_META_RCURLYBRACKET
+#define NANO_UNINDENT_KEY		NANO_META_LCURLYBRACKET
+#define NANO_SUSPEND_KEY		NANO_CONTROL_Z
+#define NANO_ENTER_KEY			NANO_CONTROL_M
+#define NANO_TOFILES_KEY		NANO_CONTROL_T
+#define NANO_APPEND_KEY			NANO_META_A
+#define NANO_PREPEND_KEY		NANO_META_P
+#define NANO_PREVFILE_KEY		NANO_META_LCARET
+#define NANO_PREVFILE_METAKEY		NANO_META_COMMA
+#define NANO_NEXTFILE_KEY		NANO_META_RCARET
+#define NANO_NEXTFILE_METAKEY		NANO_META_PERIOD
+#define NANO_BRACKET_KEY		NANO_META_RBRACKET
+#define NANO_NEXTWORD_KEY		NANO_CONTROL_SPACE
+#define NANO_PREVWORD_KEY		NANO_META_SPACE
+#define NANO_WORDCOUNT_KEY		NANO_META_D
+#define NANO_SCROLLUP_KEY		NANO_META_MINUS
+#define NANO_SCROLLDOWN_KEY		NANO_META_PLUS
+#define NANO_SCROLLUP_METAKEY		NANO_META_UNDERSCORE
+#define NANO_SCROLLDOWN_METAKEY		NANO_META_EQUALS
+#define NANO_CUTTILLEND_METAKEY		NANO_META_T
+#define NANO_PARABEGIN_KEY		NANO_CONTROL_W
+#define NANO_PARABEGIN_METAKEY		NANO_META_LPARENTHESIS
+#define NANO_PARABEGIN_METAKEY2		NANO_META_9
+#define NANO_PARAEND_KEY		NANO_CONTROL_O
+#define NANO_PARAEND_METAKEY		NANO_META_RPARENTHESIS
+#define NANO_PARAEND_METAKEY2		NANO_META_0
+#define NANO_FULLJUSTIFY_KEY		NANO_CONTROL_U
+#define NANO_FULLJUSTIFY_METAKEY	NANO_META_J
+#define NANO_VERBATIM_KEY		NANO_META_V
+
+/* Toggles do not exist if NANO_TINY is defined. */
+#ifndef NANO_TINY
+
+/* No toggle at all. */
+#define TOGGLE_NO_KEY			-2
+
+/* Normal toggles. */
+#define TOGGLE_NOHELP_KEY		NANO_META_X
+#define TOGGLE_CONST_KEY		NANO_META_C
+#define TOGGLE_MORESPACE_KEY		NANO_META_O
+#define TOGGLE_SMOOTH_KEY		NANO_META_S
+#define TOGGLE_WHITESPACE_KEY		NANO_META_P
+#define TOGGLE_SYNTAX_KEY		NANO_META_Y
+#define TOGGLE_SMARTHOME_KEY		NANO_META_H
+#define TOGGLE_AUTOINDENT_KEY		NANO_META_I
+#define TOGGLE_CUTTOEND_KEY		NANO_META_K
+#define TOGGLE_WRAP_KEY			NANO_META_L
+#define TOGGLE_TABSTOSPACES_KEY		NANO_META_Q
+#define TOGGLE_BACKUP_KEY		NANO_META_B
+#define TOGGLE_MULTIBUFFER_KEY		NANO_META_F
+#define TOGGLE_MOUSE_KEY		NANO_META_M
+#define TOGGLE_NOCONVERT_KEY		NANO_META_N
+#define TOGGLE_SUSPEND_KEY		NANO_META_Z
+#define TOGGLE_CASE_KEY			NANO_META_C
+#define TOGGLE_BACKWARDS_KEY		NANO_META_B
+#define TOGGLE_DOS_KEY			NANO_META_D
+#define TOGGLE_MAC_KEY			NANO_META_M
+
+/* Extra bits for the undo function */
+#define UNdel_del		(1<<0)
+#define UNdel_backspace	(1<<1)
+#define UNsplit_madenew	(1<<2)
+
+/* Since in ISO C you can't pass around function pointers anymore,
+  let's make some integer macros for function names, and then I
+  can go cut my wrists after writing the big switch statement
+  that will necessitate. */
+
+#endif /* !NANO_TINY */
+
+#define VIEW TRUE
+#define NOVIEW FALSE
+
+/* The maximum number of entries displayed in the main shortcut list. */
+#define MAIN_VISIBLE 12
+
+/* The minimum editor window columns and rows required for nano to work
+ * correctly. */
+#define MIN_EDITOR_COLS 4
+#define MIN_EDITOR_ROWS 1
+
+/* The default number of characters from the end of the line where
+ * wrapping occurs. */
+#define CHARS_FROM_EOL 8
+
+/* The default width of a tab in spaces. */
+#define WIDTH_OF_TAB 8
+
+/* The maximum number of search/replace history strings saved, not
+ * counting the blank lines at their ends. */
+#define MAX_SEARCH_HISTORY 100
+
+/* The maximum number of bytes buffered at one time. */
+#define MAX_BUF_SIZE 128
+
+#endif /* !NANO_H */
diff --git a/src/prompt.c b/src/prompt.c
new file mode 100644
index 0000000..0be25f5
--- /dev/null
+++ b/src/prompt.c
@@ -0,0 +1,1363 @@
+/* $Id: prompt.c 4527 2011-02-07 14:45:56Z astyanax $ */
+/**************************************************************************
+ *   prompt.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 <stdarg.h>
+#include <string.h>
+
+static char *prompt = NULL;
+	/* The prompt string used for statusbar questions. */
+static size_t statusbar_x = (size_t)-1;
+	/* The cursor position in answer. */
+static size_t statusbar_pww = (size_t)-1;
+	/* The place we want in answer. */
+static size_t old_statusbar_x = (size_t)-1;
+	/* The old cursor position in answer, if any. */
+static size_t old_pww = (size_t)-1;
+	/* The old place we want in answer, if any. */
+static bool reset_statusbar_x = FALSE;
+	/* Should we reset the cursor position at the statusbar
+	 * prompt? */
+
+/* Read in a character, interpret it as a shortcut or toggle if
+ * necessary, and return it.  Set meta_key to TRUE if the character is a
+ * meta sequence, set func_key to TRUE if the character is a function
+ * key, set have_shortcut to TRUE if the character is a shortcut
+ * key, set ran_func to TRUE if we ran a function associated with a
+ * shortcut key, and set finished to TRUE if we're done after running
+ * or trying to run a function associated with a shortcut key.  If
+ * allow_funcs is FALSE, don't actually run any functions associated
+ * with shortcut keys.  refresh_func is the function we will call to
+ * refresh the edit window. */
+int do_statusbar_input(bool *meta_key, bool *func_key, bool *have_shortcut,
+	bool *ran_func, bool *finished, bool allow_funcs, void
+	(*refresh_func)(void))
+{
+    int input;
+	/* The character we read in. */
+    static int *kbinput = NULL;
+	/* The input buffer. */
+    static size_t kbinput_len = 0;
+	/* The length of the input buffer. */
+    const sc *s;
+    const subnfunc *f;
+
+    *have_shortcut = FALSE;
+    *ran_func = FALSE;
+    *finished = FALSE;
+
+    /* Read in a character. */
+    input = get_kbinput(bottomwin, meta_key, func_key);
+
+#ifndef DISABLE_MOUSE
+    if (allow_funcs) {
+	/* If we got a mouse click and it was on a shortcut, read in the
+	 * shortcut character. */
+	if (*func_key && input == KEY_MOUSE) {
+	    if (do_statusbar_mouse() == 1)
+		input = get_kbinput(bottomwin, meta_key, func_key);
+	    else {
+		*meta_key = FALSE;
+		*func_key = FALSE;
+		input = ERR;
+	    }
+	}
+    }
+#endif
+
+    /* Check for a shortcut in the current list. */
+    s = get_shortcut(currmenu, &input, meta_key, func_key);
+
+    /* If we got a shortcut from the current list, or a "universal"
+     * statusbar prompt 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 || *func_key) {
+	    beep();
+	    *meta_key = FALSE;
+	    *func_key = FALSE;
+	    input = ERR;
+	}
+    }
+
+    if (allow_funcs) {
+	/* If we got a character, and it isn't a shortcut or toggle,
+	 * it's a normal text character.  Display the warning if we're
+	 * in view mode, or add the character to the input buffer if
+	 * we're not. */
+	if (input != ERR && !*have_shortcut) {
+	    /* If we're using restricted mode, the filename isn't blank,
+	     * and we're at the "Write File" prompt, disable text
+	     * input. */
+	    if (!ISSET(RESTRICTED) || openfile->filename[0] == '\0' ||
+		currmenu != MWRITEFILE) {
+		kbinput_len++;
+		kbinput = (int *)nrealloc(kbinput, kbinput_len *
+			sizeof(int));
+		kbinput[kbinput_len - 1] = input;
+	    }
+	}
+
+	/* If we got a shortcut, or if there aren't any other characters
+	 * waiting after the one we read in, we need to display all the
+	 * characters in the input buffer if it isn't empty. */
+	 if (*have_shortcut || get_key_buffer_len() == 0) {
+	    if (kbinput != NULL) {
+		/* Display all the characters in the input buffer at
+		 * once, filtering out control characters. */
+		char *output = charalloc(kbinput_len + 1);
+		size_t i;
+		bool got_enter;
+			/* Whether we got the Enter key. */
+
+		for (i = 0; i < kbinput_len; i++)
+		    output[i] = (char)kbinput[i];
+		output[i] = '\0';
+
+		do_statusbar_output(output, kbinput_len, &got_enter,
+			FALSE);
+
+		free(output);
+
+		/* Empty the input buffer. */
+		kbinput_len = 0;
+		free(kbinput);
+		kbinput = NULL;
+	    }
+	}
+
+	if (*have_shortcut) {
+	    if (s->scfunc == do_tab || s->scfunc == do_enter_void)
+		;
+	    else if (s->scfunc == total_refresh)
+		total_statusbar_refresh(refresh_func);
+            else if (s->scfunc == do_cut_text_void) {
+		/* If we're using restricted mode, the filename
+		 * isn't blank, and we're at the "Write File"
+		 * prompt, disable Cut. */
+		if (!ISSET(RESTRICTED) || openfile->filename[0] ==
+			'\0' || currmenu != MWRITEFILE)
+		    do_statusbar_cut_text();
+	    } else if (s->scfunc == do_right)
+		do_statusbar_right();
+	    else if (s->scfunc == do_left)
+		do_statusbar_left();
+
+#ifndef NANO_TINY
+	    else if (s->scfunc == do_next_word_void)
+		do_statusbar_next_word(FALSE);
+	    else if (s->scfunc == do_prev_word_void)
+		    do_statusbar_prev_word(FALSE);
+#endif
+	    else if (s->scfunc == do_home)
+		    do_statusbar_home();
+	    else if (s->scfunc == do_end)
+		    do_statusbar_end();
+
+#ifndef NANO_TINY
+	    else if (s->scfunc == do_find_bracket)
+		do_statusbar_find_bracket();
+#endif
+	    else if (s->scfunc == do_verbatim_input) {
+		    /* If we're using restricted mode, the filename
+		     * isn't blank, and we're at the "Write File"
+	   	     * prompt, disable verbatim input. */
+		    if (!ISSET(RESTRICTED) ||
+			openfile->filename[0] == '\0' ||
+			currmenu != MWRITEFILE) {
+			    bool got_enter;
+			    /* Whether we got the Enter key. */
+
+			    do_statusbar_verbatim_input(&got_enter);
+
+			    /* If we got the Enter key, remove it from
+			     * the input buffer, set input to the key
+			     * value for Enter, and set finished to TRUE
+			     * to indicate that we're done. */
+			    if (got_enter) {
+				get_input(NULL, 1);
+				input = sc_seq_or(do_enter_void, 0);
+				*finished = TRUE;
+			    }
+		    }
+	    } else if (s->scfunc == do_delete) {
+		/* If we're using restricted mode, the filename
+		 * isn't blank, and we're at the "Write File"
+		 * prompt, disable Delete. */
+		if (!ISSET(RESTRICTED) || openfile->filename[0] ==
+			'\0' || currmenu != MWRITEFILE)
+		    do_statusbar_delete();
+	    } else if (s->scfunc == do_backspace) {
+		/* If we're using restricted mode, the filename
+		 * isn't blank, and we're at the "Write File"
+		 * prompt, disable Backspace. */
+		if (!ISSET(RESTRICTED) || openfile->filename[0] ==
+			'\0' || currmenu != MWRITEFILE)
+		    do_statusbar_backspace();
+	    } else {
+	    /* Handle the normal statusbar prompt shortcuts, setting
+	     * ran_func to TRUE if we try to run their associated
+	     * functions and setting finished to TRUE to indicate
+	     * that we're done after running or trying to run their
+	     * associated functions. */
+
+		f = sctofunc((sc *) s);
+		if (s->scfunc != 0 &&  s->execute == TRUE) {
+			*ran_func = TRUE;
+		    if (f && (!ISSET(VIEW_MODE) || (f->viewok)))
+		        f->scfunc();
+		}
+		*finished = TRUE;
+	    }
+	}
+    }
+
+    return input;
+}
+
+#ifndef DISABLE_MOUSE
+/* Handle a mouse click on the statusbar prompt or the shortcut list. */
+int do_statusbar_mouse(void)
+{
+    int mouse_x, mouse_y;
+    int retval = get_mouseinput(&mouse_x, &mouse_y, TRUE);
+
+    /* We can click on the statusbar window text to move the cursor. */
+    if (retval == 0 && wmouse_trafo(bottomwin, &mouse_y, &mouse_x,
+	FALSE)) {
+	size_t start_col;
+
+	assert(prompt != NULL);
+
+	start_col = strlenpt(prompt) + 2;
+
+	/* Move to where the click occurred. */
+	if (mouse_x >= start_col && mouse_y == 0) {
+	    size_t pww_save = statusbar_pww;
+
+	    statusbar_x = actual_x(answer,
+			get_statusbar_page_start(start_col, start_col +
+			statusbar_xplustabs()) + mouse_x - start_col);
+	    statusbar_pww = statusbar_xplustabs();
+
+	    if (need_statusbar_horizontal_update(pww_save))
+		update_statusbar_line(answer, statusbar_x);
+	}
+    }
+
+    return retval;
+}
+#endif
+
+/* The user typed output_len multibyte characters.  Add them to the
+ * statusbar prompt, setting got_enter to TRUE if we get a newline, and
+ * filtering out all ASCII control characters if allow_cntrls is
+ * TRUE. */
+void do_statusbar_output(char *output, size_t output_len, bool
+	*got_enter, bool allow_cntrls)
+{
+    size_t answer_len, i = 0;
+    char *char_buf = charalloc(mb_cur_max());
+    int char_buf_len;
+
+    assert(answer != NULL);
+
+    answer_len = strlen(answer);
+    *got_enter = FALSE;
+
+    while (i < output_len) {
+	/* If allow_cntrls is TRUE, convert nulls and newlines
+	 * properly. */
+	if (allow_cntrls) {
+	    /* Null to newline, if needed. */
+	    if (output[i] == '\0')
+		output[i] = '\n';
+	    /* Newline to Enter, if needed. */
+	    else if (output[i] == '\n') {
+		/* Set got_enter to TRUE to indicate that we got the
+		 * Enter key, put back the rest of the characters in
+		 * output so that they can be parsed and output again,
+		 * and get out. */
+		*got_enter = TRUE;
+		unparse_kbinput(output + i, output_len - i);
+		return;
+	    }
+	}
+
+	/* Interpret the next multibyte character. */
+	char_buf_len = parse_mbchar(output + i, char_buf, NULL);
+
+	i += char_buf_len;
+
+	/* If allow_cntrls is FALSE, filter out an ASCII control
+	 * character. */
+	if (!allow_cntrls && is_ascii_cntrl_char(*(output + i -
+		char_buf_len)))
+	    continue;
+
+	/* More dangerousness fun =) */
+	answer = charealloc(answer, answer_len + (char_buf_len * 2));
+
+	assert(statusbar_x <= answer_len);
+
+	charmove(answer + statusbar_x + char_buf_len,
+		answer + statusbar_x, answer_len - statusbar_x +
+		char_buf_len);
+	strncpy(answer + statusbar_x, char_buf, char_buf_len);
+	answer_len += char_buf_len;
+
+	statusbar_x += char_buf_len;
+    }
+
+    free(char_buf);
+
+    statusbar_pww = statusbar_xplustabs();
+
+    update_statusbar_line(answer, statusbar_x);
+}
+
+/* Move to the beginning of the prompt text.  If the SMART_HOME flag is
+ * set, move to the first non-whitespace character of the prompt text if
+ * we're not already there, or to the beginning of the prompt text if we
+ * are. */
+void do_statusbar_home(void)
+{
+    size_t pww_save = statusbar_pww;
+
+#ifndef NANO_TINY
+    if (ISSET(SMART_HOME)) {
+	size_t statusbar_x_save = statusbar_x;
+
+	statusbar_x = indent_length(answer);
+
+	if (statusbar_x == statusbar_x_save ||
+		statusbar_x == strlen(answer))
+	    statusbar_x = 0;
+
+	statusbar_pww = statusbar_xplustabs();
+    } else {
+#endif
+	statusbar_x = 0;
+	statusbar_pww = statusbar_xplustabs();
+#ifndef NANO_TINY
+    }
+#endif
+
+    if (need_statusbar_horizontal_update(pww_save))
+	update_statusbar_line(answer, statusbar_x);
+}
+
+/* Move to the end of the prompt text. */
+void do_statusbar_end(void)
+{
+    size_t pww_save = statusbar_pww;
+
+    statusbar_x = strlen(answer);
+    statusbar_pww = statusbar_xplustabs();
+
+    if (need_statusbar_horizontal_update(pww_save))
+	update_statusbar_line(answer, statusbar_x);
+}
+
+/* Move left one character. */
+void do_statusbar_left(void)
+{
+    if (statusbar_x > 0) {
+	size_t pww_save = statusbar_pww;
+
+	statusbar_x = move_mbleft(answer, statusbar_x);
+	statusbar_pww = statusbar_xplustabs();
+
+	if (need_statusbar_horizontal_update(pww_save))
+	    update_statusbar_line(answer, statusbar_x);
+    }
+}
+
+/* Move right one character. */
+void do_statusbar_right(void)
+{
+    if (statusbar_x < strlen(answer)) {
+	size_t pww_save = statusbar_pww;
+
+	statusbar_x = move_mbright(answer, statusbar_x);
+	statusbar_pww = statusbar_xplustabs();
+
+	if (need_statusbar_horizontal_update(pww_save))
+	    update_statusbar_line(answer, statusbar_x);
+    }
+}
+
+/* Backspace over one character. */
+void do_statusbar_backspace(void)
+{
+    if (statusbar_x > 0) {
+	do_statusbar_left();
+	do_statusbar_delete();
+    }
+}
+
+/* Delete one character. */
+void do_statusbar_delete(void)
+{
+    statusbar_pww = statusbar_xplustabs();
+
+    if (answer[statusbar_x] != '\0') {
+	int char_buf_len = parse_mbchar(answer + statusbar_x, NULL,
+		NULL);
+	size_t line_len = strlen(answer + statusbar_x);
+
+	assert(statusbar_x < strlen(answer));
+
+	charmove(answer + statusbar_x, answer + statusbar_x +
+		char_buf_len, strlen(answer) - statusbar_x -
+		char_buf_len + 1);
+
+	null_at(&answer, statusbar_x + line_len - char_buf_len);
+
+	update_statusbar_line(answer, statusbar_x);
+    }
+}
+
+/* Move text from the prompt into oblivion. */
+void do_statusbar_cut_text(void)
+{
+    assert(answer != NULL);
+
+#ifndef NANO_TINY
+    if (ISSET(CUT_TO_END))
+	null_at(&answer, statusbar_x);
+    else {
+#endif
+	null_at(&answer, 0);
+	statusbar_x = 0;
+	statusbar_pww = statusbar_xplustabs();
+#ifndef NANO_TINY
+    }
+#endif
+
+    update_statusbar_line(answer, statusbar_x);
+}
+
+#ifndef NANO_TINY
+/* Move to the next word in the prompt text.  If allow_punct is TRUE,
+ * treat punctuation as part of a word.  Return TRUE if we started on a
+ * word, and FALSE otherwise. */
+bool do_statusbar_next_word(bool allow_punct)
+{
+    size_t pww_save = statusbar_pww;
+    char *char_mb;
+    int char_mb_len;
+    bool end_line = FALSE, started_on_word = FALSE;
+
+    assert(answer != NULL);
+
+    char_mb = charalloc(mb_cur_max());
+
+    /* Move forward until we find the character after the last letter of
+     * the current word. */
+    while (!end_line) {
+	char_mb_len = parse_mbchar(answer + statusbar_x, char_mb, NULL);
+
+	/* If we've found it, stop moving forward through the current
+	 * line. */
+	if (!is_word_mbchar(char_mb, allow_punct))
+	    break;
+
+	/* If we haven't found it, then we've started on a word, so set
+	 * started_on_word to TRUE. */
+	started_on_word = TRUE;
+
+	if (answer[statusbar_x] == '\0')
+	    end_line = TRUE;
+	else
+	    statusbar_x += char_mb_len;
+    }
+
+    /* Move forward until we find the first letter of the next word. */
+    if (answer[statusbar_x] == '\0')
+	end_line = TRUE;
+    else
+	statusbar_x += char_mb_len;
+
+    while (!end_line) {
+	char_mb_len = parse_mbchar(answer + statusbar_x, char_mb, NULL);
+
+	/* If we've found it, stop moving forward through the current
+	 * line. */
+	if (is_word_mbchar(char_mb, allow_punct))
+	    break;
+
+	if (answer[statusbar_x] == '\0')
+	    end_line = TRUE;
+	else
+	    statusbar_x += char_mb_len;
+    }
+
+    free(char_mb);
+
+    statusbar_pww = statusbar_xplustabs();
+
+    if (need_statusbar_horizontal_update(pww_save))
+	update_statusbar_line(answer, statusbar_x);
+
+    /* Return whether we started on a word. */
+    return started_on_word;
+}
+
+/* Move to the previous word in the prompt text.  If allow_punct is
+ * TRUE, treat punctuation as part of a word.  Return TRUE if we started
+ * on a word, and FALSE otherwise. */
+bool do_statusbar_prev_word(bool allow_punct)
+{
+    size_t pww_save = statusbar_pww;
+    char *char_mb;
+    int char_mb_len;
+    bool begin_line = FALSE, started_on_word = FALSE;
+
+    assert(answer != NULL);
+
+    char_mb = charalloc(mb_cur_max());
+
+    /* Move backward until we find the character before the first letter
+     * of the current word. */
+    while (!begin_line) {
+	char_mb_len = parse_mbchar(answer + statusbar_x, char_mb, NULL);
+
+	/* If we've found it, stop moving backward through the current
+	 * line. */
+	if (!is_word_mbchar(char_mb, allow_punct))
+	    break;
+
+	/* If we haven't found it, then we've started on a word, so set
+	 * started_on_word to TRUE. */
+	started_on_word = TRUE;
+
+	if (statusbar_x == 0)
+	    begin_line = TRUE;
+	else
+	    statusbar_x = move_mbleft(answer, statusbar_x);
+    }
+
+    /* Move backward until we find the last letter of the previous
+     * word. */
+    if (statusbar_x == 0)
+	begin_line = TRUE;
+    else
+	statusbar_x = move_mbleft(answer, statusbar_x);
+
+    while (!begin_line) {
+	char_mb_len = parse_mbchar(answer + statusbar_x, char_mb, NULL);
+
+	/* If we've found it, stop moving backward through the current
+	 * line. */
+	if (is_word_mbchar(char_mb, allow_punct))
+	    break;
+
+	if (statusbar_x == 0)
+	    begin_line = TRUE;
+	else
+	    statusbar_x = move_mbleft(answer, statusbar_x);
+    }
+
+    /* If we've found it, move backward until we find the character
+     * before the first letter of the previous word. */
+    if (!begin_line) {
+	if (statusbar_x == 0)
+	    begin_line = TRUE;
+	else
+	    statusbar_x = move_mbleft(answer, statusbar_x);
+
+	while (!begin_line) {
+	    char_mb_len = parse_mbchar(answer + statusbar_x, char_mb,
+		NULL);
+
+	    /* If we've found it, stop moving backward through the
+	     * current line. */
+	    if (!is_word_mbchar(char_mb, allow_punct))
+		break;
+
+	    if (statusbar_x == 0)
+		begin_line = TRUE;
+	    else
+		statusbar_x = move_mbleft(answer, statusbar_x);
+	}
+
+	/* If we've found it, move forward to the first letter of the
+	 * previous word. */
+	if (!begin_line)
+	    statusbar_x += char_mb_len;
+    }
+
+    free(char_mb);
+
+    statusbar_pww = statusbar_xplustabs();
+
+    if (need_statusbar_horizontal_update(pww_save))
+	update_statusbar_line(answer, statusbar_x);
+
+    /* Return whether we started on a word. */
+    return started_on_word;
+}
+#endif /* !NANO_TINY */
+
+/* Get verbatim input.  Set got_enter to TRUE if we got the Enter key as
+ * part of the verbatim input. */
+void do_statusbar_verbatim_input(bool *got_enter)
+{
+    int *kbinput;
+    size_t kbinput_len, i;
+    char *output;
+
+    *got_enter = FALSE;
+
+    /* Read in all the verbatim characters. */
+    kbinput = get_verbatim_kbinput(bottomwin, &kbinput_len);
+
+    /* 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';
+
+    do_statusbar_output(output, kbinput_len, got_enter, TRUE);
+
+    free(output);
+}
+
+#ifndef NANO_TINY
+/* Search for a match to one of the two characters in bracket_set.  If
+ * reverse is TRUE, search backwards for the leftmost bracket.
+ * Otherwise, search forwards for the rightmost bracket.  Return TRUE if
+ * we found a match, and FALSE otherwise. */
+bool find_statusbar_bracket_match(bool reverse, const char
+	*bracket_set)
+{
+    const char *rev_start = NULL, *found = NULL;
+
+    assert(mbstrlen(bracket_set) == 2);
+
+    /* rev_start might end up 1 character before the start or after the
+     * end of the line.  This won't be a problem because we'll skip over
+     * it below in that case. */
+    rev_start = reverse ? answer + (statusbar_x - 1) : answer +
+	(statusbar_x + 1);
+
+    while (TRUE) {
+	/* Look for either of the two characters in bracket_set.
+	 * rev_start can be 1 character before the start or after the
+	 * end of the line.  In either case, just act as though no match
+	 * is found. */
+	found = ((rev_start > answer && *(rev_start - 1) == '\0') ||
+		rev_start < answer) ? NULL : (reverse ?
+		mbrevstrpbrk(answer, bracket_set, rev_start) :
+		mbstrpbrk(rev_start, bracket_set));
+
+	/* We've found a potential match. */
+	if (found != NULL)
+	    break;
+
+	/* We've reached the start or end of the statusbar text, so
+	 * get out. */
+	return FALSE;
+    }
+
+    /* We've definitely found something. */
+    statusbar_x = found - answer;
+    statusbar_pww = statusbar_xplustabs();
+
+    return TRUE;
+}
+
+/* Search for a match to the bracket at the current cursor position, if
+ * there is one. */
+void do_statusbar_find_bracket(void)
+{
+    size_t statusbar_x_save, pww_save;
+    const char *ch;
+	/* The location in matchbrackets of the bracket at the current
+	 * cursor position. */
+    int ch_len;
+	/* The length of ch in bytes. */
+    const char *wanted_ch;
+	/* The location in matchbrackets of the bracket complementing
+	 * the bracket at the current cursor position. */
+    int wanted_ch_len;
+	/* The length of wanted_ch in bytes. */
+    char *bracket_set;
+	/* The pair of characters in ch and wanted_ch. */
+    size_t i;
+	/* Generic loop variable. */
+    size_t matchhalf;
+	/* The number of single-byte characters in one half of
+	 * matchbrackets. */
+    size_t mbmatchhalf;
+	/* The number of multibyte characters in one half of
+	 * matchbrackets. */
+    size_t count = 1;
+	/* The initial bracket count. */
+    bool reverse;
+	/* The direction we search. */
+    char *found_ch;
+	/* The character we find. */
+
+    assert(mbstrlen(matchbrackets) % 2 == 0);
+
+    ch = answer + statusbar_x;
+
+    if (ch == '\0' || (ch = mbstrchr(matchbrackets, ch)) == NULL)
+	return;
+
+    /* Save where we are. */
+    statusbar_x_save = statusbar_x;
+    pww_save = statusbar_pww;
+
+    /* If we're on an opening bracket, which must be in the first half
+     * of matchbrackets, we want to search forwards for a closing
+     * bracket.  If we're on a closing bracket, which must be in the
+     * second half of matchbrackets, we want to search backwards for an
+     * opening bracket. */
+    matchhalf = 0;
+    mbmatchhalf = mbstrlen(matchbrackets) / 2;
+
+    for (i = 0; i < mbmatchhalf; i++)
+	matchhalf += parse_mbchar(matchbrackets + matchhalf, NULL,
+		NULL);
+
+    reverse = ((ch - matchbrackets) >= matchhalf);
+
+    /* If we're on an opening bracket, set wanted_ch to the character
+     * that's matchhalf characters after ch.  If we're on a closing
+     * bracket, set wanted_ch to the character that's matchhalf
+     * characters before ch. */
+    wanted_ch = ch;
+
+    while (mbmatchhalf > 0) {
+	if (reverse)
+	    wanted_ch = matchbrackets + move_mbleft(matchbrackets,
+		wanted_ch - matchbrackets);
+	else
+	    wanted_ch += move_mbright(wanted_ch, 0);
+
+	mbmatchhalf--;
+    }
+
+    ch_len = parse_mbchar(ch, NULL, NULL);
+    wanted_ch_len = parse_mbchar(wanted_ch, NULL, NULL);
+
+    /* Fill bracket_set in with the values of ch and wanted_ch. */
+    bracket_set = charalloc((mb_cur_max() * 2) + 1);
+    strncpy(bracket_set, ch, ch_len);
+    strncpy(bracket_set + ch_len, wanted_ch, wanted_ch_len);
+    null_at(&bracket_set, ch_len + wanted_ch_len);
+
+    found_ch = charalloc(mb_cur_max() + 1);
+
+    while (TRUE) {
+	if (find_statusbar_bracket_match(reverse, bracket_set)) {
+	    /* If we found an identical bracket, increment count.  If we
+	     * found a complementary bracket, decrement it. */
+	    parse_mbchar(answer + statusbar_x, found_ch, NULL);
+	    count += (strncmp(found_ch, ch, ch_len) == 0) ? 1 : -1;
+
+	    /* If count is zero, we've found a matching bracket.  Update
+	     * the statusbar prompt and get out. */
+	    if (count == 0) {
+		if (need_statusbar_horizontal_update(pww_save))
+		    update_statusbar_line(answer, statusbar_x);
+		break;
+	    }
+	} else {
+	    /* We didn't find either an opening or closing bracket.
+	     * Restore where we were, and get out. */
+	    statusbar_x = statusbar_x_save;
+	    statusbar_pww = pww_save;
+	    break;
+	}
+    }
+
+    /* Clean up. */
+    free(bracket_set);
+    free(found_ch);
+}
+#endif /* !NANO_TINY */
+
+/* Return the placewewant associated with statusbar_x, i.e. the
+ * zero-based column position of the cursor.  The value will be no
+ * smaller than statusbar_x. */
+size_t statusbar_xplustabs(void)
+{
+    return strnlenpt(answer, statusbar_x);
+}
+
+/* nano scrolls horizontally within a line in chunks.  This function
+ * returns the column number of the first character displayed in the
+ * statusbar prompt when the cursor is at the given column with the
+ * prompt ending at start_col.  Note that (0 <= column -
+ * get_statusbar_page_start(column) < COLS). */
+size_t get_statusbar_page_start(size_t start_col, size_t column)
+{
+    if (column == start_col || column < COLS - 1)
+	return 0;
+    else
+	return column - start_col - (column - start_col) % (COLS -
+		start_col - 1);
+}
+
+/* Put the cursor in the statusbar prompt at statusbar_x. */
+void reset_statusbar_cursor(void)
+{
+    size_t start_col = strlenpt(prompt) + 2;
+    size_t xpt = statusbar_xplustabs();
+
+    wmove(bottomwin, 0, start_col + xpt -
+	get_statusbar_page_start(start_col, start_col + xpt));
+}
+
+/* Repaint the statusbar when getting a character in
+ * get_prompt_string().  The statusbar text line will be displayed
+ * starting with curranswer[index]. */
+void update_statusbar_line(const char *curranswer, size_t index)
+{
+    size_t start_col, page_start;
+    char *expanded;
+
+    assert(prompt != NULL && index <= strlen(curranswer));
+
+    start_col = strlenpt(prompt) + 2;
+    index = strnlenpt(curranswer, index);
+    page_start = get_statusbar_page_start(start_col, start_col + index);
+
+    wattron(bottomwin, reverse_attr);
+
+    blank_statusbar();
+
+    mvwaddnstr(bottomwin, 0, 0, prompt, actual_x(prompt, COLS - 2));
+    waddch(bottomwin, ':');
+    waddch(bottomwin, (page_start == 0) ? ' ' : '$');
+
+    expanded = display_string(curranswer, page_start, COLS - start_col -
+	1, FALSE);
+    waddstr(bottomwin, expanded);
+    free(expanded);
+
+    wattroff(bottomwin, reverse_attr);
+    statusbar_pww = statusbar_xplustabs();
+    reset_statusbar_cursor();
+    wnoutrefresh(bottomwin);
+}
+
+/* Return TRUE if we need an update after moving horizontally, and FALSE
+ * otherwise.  We need one if pww_save and statusbar_pww are on
+ * different pages. */
+bool need_statusbar_horizontal_update(size_t pww_save)
+{
+    size_t start_col = strlenpt(prompt) + 2;
+
+    return get_statusbar_page_start(start_col, start_col + pww_save) !=
+	get_statusbar_page_start(start_col, start_col + statusbar_pww);
+}
+
+/* Unconditionally redraw the entire screen, and then refresh it using
+ * refresh_func(). */
+void total_statusbar_refresh(void (*refresh_func)(void))
+{
+    total_redraw();
+    refresh_func();
+}
+
+/* Get a string of input at the statusbar prompt.  This should only be
+ * called from do_prompt(). */
+const sc *get_prompt_string(int *actual, bool allow_tabs,
+#ifndef DISABLE_TABCOMP
+	bool allow_files,
+#endif
+	const char *curranswer,
+	bool *meta_key, bool *func_key,
+#ifndef NANO_TINY
+	filestruct **history_list,
+#endif
+	void (*refresh_func)(void), int menu
+#ifndef DISABLE_TABCOMP
+	, bool *list
+#endif
+	)
+{
+    int kbinput = ERR;
+    bool have_shortcut, ran_func, finished;
+    size_t curranswer_len;
+    const sc *s;
+#ifndef DISABLE_TABCOMP
+    bool tabbed = FALSE;
+	/* Whether we've pressed Tab. */
+#endif
+#ifndef NANO_TINY
+    char *history = NULL;
+	/* The current history string. */
+    char *magichistory = NULL;
+	/* The temporary string typed at the bottom of the history, if
+	 * any. */
+#ifndef DISABLE_TABCOMP
+    int last_kbinput = ERR;
+	/* The key we pressed before the current key. */
+    size_t complete_len = 0;
+	/* The length of the original string that we're trying to
+	 * tab complete, if any. */
+#endif
+#endif /* !NANO_TINY */
+
+    answer = mallocstrcpy(answer, curranswer);
+    curranswer_len = strlen(answer);
+
+    /* If reset_statusbar_x is TRUE, restore statusbar_x and
+     * statusbar_pww to what they were before this prompt.  Then, if
+     * statusbar_x is uninitialized or past the end of curranswer, put
+     * statusbar_x at the end of the string and update statusbar_pww
+     * based on it.  We do these things so that the cursor position
+     * stays at the right place if a prompt-changing toggle is pressed,
+     * or if this prompt was started from another prompt and we cancel
+     * out of it. */
+    if (reset_statusbar_x) {
+	statusbar_x = old_statusbar_x;
+	statusbar_pww = old_pww;
+    }
+
+    if (statusbar_x == (size_t)-1 || statusbar_x > curranswer_len) {
+	statusbar_x = curranswer_len;
+	statusbar_pww = statusbar_xplustabs();
+    }
+
+    currmenu = menu;
+
+#ifdef DEBUG
+fprintf(stderr, "get_prompt_string: answer = \"%s\", statusbar_x = %lu\n", answer, (unsigned long) statusbar_x);
+#endif
+
+    update_statusbar_line(answer, statusbar_x);
+
+    /* Refresh the edit window and the statusbar before getting
+     * input. */
+    wnoutrefresh(edit);
+    wnoutrefresh(bottomwin);
+
+    /* If we're using restricted mode, we aren't allowed to change the
+     * name of the current file once it has one, because that would
+     * allow writing to files not specified on the command line.  In
+     * this case, disable all keys that would change the text if the
+     * filename isn't blank and we're at the "Write File" prompt. */
+    while (1) {
+	kbinput = do_statusbar_input(meta_key, func_key, &have_shortcut,
+	    &ran_func, &finished, TRUE, refresh_func);
+	assert(statusbar_x <= strlen(answer));
+
+	s = get_shortcut(currmenu, &kbinput, meta_key, func_key);
+
+	if (s)
+	    if (s->scfunc == do_cancel || s->scfunc == do_enter_void)
+		break;
+
+#ifndef DISABLE_TABCOMP
+	if (s && s->scfunc != do_tab)
+	    tabbed = FALSE;
+#endif
+
+#ifndef DISABLE_TABCOMP
+#ifndef NANO_TINY
+	if (s && s->scfunc == do_tab) {
+		if (history_list != NULL) {
+		    if (last_kbinput != sc_seq_or(do_tab, NANO_CONTROL_I))
+			complete_len = strlen(answer);
+
+		    if (complete_len > 0) {
+			answer = mallocstrcpy(answer,
+				get_history_completion(history_list,
+				answer, complete_len));
+			statusbar_x = strlen(answer);
+		    }
+		} else
+#endif /* !NANO_TINY */
+		if (allow_tabs)
+		    answer = input_tab(answer, allow_files,
+			&statusbar_x, &tabbed, refresh_func, list);
+
+		update_statusbar_line(answer, statusbar_x);
+	} else
+#endif /* !DISABLE_TABCOMP */
+#ifndef NANO_TINY
+	if (s && s->scfunc == get_history_older_void) {
+		if (history_list != NULL) {
+		    /* If we're scrolling up at the bottom of the
+		     * history list and answer isn't blank, save answer
+		     * in magichistory. */
+		    if ((*history_list)->next == NULL &&
+			answer[0] != '\0')
+			magichistory = mallocstrcpy(magichistory,
+				answer);
+
+		    /* Get the older search from the history list and
+		     * save it in answer.  If there is no older search,
+		     * don't do anything. */
+		    if ((history =
+			get_history_older(history_list)) != NULL) {
+			answer = mallocstrcpy(answer, history);
+			statusbar_x = strlen(answer);
+		    }
+
+		    update_statusbar_line(answer, statusbar_x);
+
+		    /* This key has a shortcut list entry when it's used
+		     * to move to an older search, which means that
+		     * finished has been set to TRUE.  Set it back to
+		     * FALSE here, so that we aren't kicked out of the
+		     * statusbar prompt. */
+		    finished = FALSE;
+		}
+	} else if (s && s->scfunc == get_history_newer_void) {
+		if (history_list != NULL) {
+		    /* Get the newer search from the history list and
+		     * save it in answer.  If there is no newer search,
+		     * don't do anything. */
+		    if ((history =
+			get_history_newer(history_list)) != NULL) {
+			answer = mallocstrcpy(answer, history);
+			statusbar_x = strlen(answer);
+		    }
+
+		    /* If, after scrolling down, we're at the bottom of
+		     * the history list, answer is blank, and
+		     * magichistory is set, save magichistory in
+		     * answer. */
+		    if ((*history_list)->next == NULL &&
+			*answer == '\0' && magichistory != NULL) {
+			answer = mallocstrcpy(answer, magichistory);
+			statusbar_x = strlen(answer);
+		    }
+
+		    update_statusbar_line(answer, statusbar_x);
+
+		    /* This key has a shortcut list entry when it's used
+		     * to move to a newer search, which means that
+		     * finished has been set to TRUE.  Set it back to
+		     * FALSE here, so that we aren't kicked out of the
+		     * statusbar prompt. */
+		    finished = FALSE;
+		}
+	} else
+#endif /* !NANO_TINY */
+	if (s && s->scfunc == do_help_void) {
+		update_statusbar_line(answer, statusbar_x);
+
+		/* This key has a shortcut list entry when it's used to
+		 * go to the help browser or display a message
+		 * indicating that help is disabled, which means that
+		 * finished has been set to TRUE.  Set it back to FALSE
+		 * here, so that we aren't kicked out of the statusbar
+		 * prompt. */
+		finished = FALSE;
+	}
+
+	/* If we have a shortcut with an associated function, break out
+	 * if we're finished after running or trying to run the
+	 * function. */
+	if (finished)
+	    break;
+
+#if !defined(NANO_TINY) && !defined(DISABLE_TABCOMP)
+	last_kbinput = kbinput;
+#endif
+
+	reset_statusbar_cursor();
+	wnoutrefresh(bottomwin);
+    }
+
+
+#ifndef NANO_TINY
+    /* Set the current position in the history list to the bottom and
+     * free magichistory, if we need to. */
+    if (history_list != NULL) {
+	history_reset(*history_list);
+
+	if (magichistory != NULL)
+	    free(magichistory);
+    }
+#endif
+
+
+    /* We've finished putting in an answer or run a normal shortcut's
+     * associated function, so reset statusbar_x and statusbar_pww.  If
+     * we've finished putting in an answer, reset the statusbar cursor
+     * position too. */
+    if (s) {
+	if (s->scfunc ==  do_cancel || s->scfunc == do_enter_void ||
+	ran_func) {
+	    statusbar_x = old_statusbar_x;
+	    statusbar_pww = old_pww;
+
+	    if (!ran_func)
+		reset_statusbar_x = TRUE;
+    /* Otherwise, we're still putting in an answer or a shortcut with
+     * an associated function, so leave the statusbar cursor position
+     * alone. */
+	} else
+	    reset_statusbar_x = FALSE;
+    }
+
+    *actual = kbinput;
+    return s;
+}
+
+/* Ask a question on the statusbar.  The prompt will be stored in the
+ * static prompt, which should be NULL initially, and the answer will be
+ * stored in the answer global.  Returns -1 on aborted enter, -2 on a
+ * blank string, and 0 otherwise, the valid shortcut key caught.
+ * curranswer is any editable text that we want to put up by default,
+ * and refresh_func is the function we want to call to refresh the edit
+ * window.
+ *
+ * The allow_tabs parameter indicates whether we should allow tabs to be
+ * interpreted.  The allow_files parameter indicates whether we should
+ * allow all files (as opposed to just directories) to be tab
+ * completed. */
+int do_prompt(bool allow_tabs,
+#ifndef DISABLE_TABCOMP
+	bool allow_files,
+#endif
+	int menu, const char *curranswer,
+	bool *meta_key, bool *func_key,
+#ifndef NANO_TINY
+	filestruct **history_list,
+#endif
+	void (*refresh_func)(void), const char *msg, ...)
+{
+    va_list ap;
+    int retval;
+    const sc *s;
+#ifndef DISABLE_TABCOMP
+    bool list = FALSE;
+#endif
+
+    /* prompt has been freed and set to NULL unless the user resized
+     * while at the statusbar prompt. */
+    if (prompt != NULL)
+	free(prompt);
+
+    prompt = charalloc(((COLS - 4) * mb_cur_max()) + 1);
+
+    bottombars(menu);
+
+    va_start(ap, msg);
+    vsnprintf(prompt, (COLS - 4) * mb_cur_max(), msg, ap);
+    va_end(ap);
+    null_at(&prompt, actual_x(prompt, COLS - 4));
+
+    s = get_prompt_string(&retval, allow_tabs,
+#ifndef DISABLE_TABCOMP
+	allow_files,
+#endif
+	curranswer,
+	meta_key, func_key,
+#ifndef NANO_TINY
+	history_list,
+#endif
+	refresh_func, menu
+#ifndef DISABLE_TABCOMP
+	, &list
+#endif
+	);
+
+    free(prompt);
+    prompt = NULL;
+
+    /* We're done with the prompt, so save the statusbar cursor
+     * position. */
+    old_statusbar_x = statusbar_x;
+    old_pww = statusbar_pww;
+
+    /* If we left the prompt via Cancel or Enter, set the return value
+     * properly. */
+    if (s && s->scfunc ==  do_cancel)
+	retval = -1;
+    else if (s && s->scfunc == do_enter_void)
+	retval = (*answer == '\0') ? -2 : 0;
+
+    blank_statusbar();
+    wnoutrefresh(bottomwin);
+
+#ifdef DEBUG
+    fprintf(stderr, "answer = \"%s\"\n", answer);
+#endif
+
+#ifndef DISABLE_TABCOMP
+    /* If we've done tab completion, there might be a list of filename
+     * matches on the edit window at this point.  Make sure that they're
+     * cleared off. */
+    if (list)
+	refresh_func();
+#endif
+
+    return retval;
+}
+
+/* This function forces a reset of the statusbar cursor position.  It
+ * should be called when we get out of all statusbar prompts. */
+void do_prompt_abort(void)
+{
+    /* Uninitialize the old cursor position in answer. */
+    old_statusbar_x = (size_t)-1;
+    old_pww = (size_t)-1;
+
+    reset_statusbar_x = TRUE;
+}
+
+/* Ask a simple Yes/No (and optionally All) question, specified in msg,
+ * on the statusbar.  Return 1 for Yes, 0 for No, 2 for All (if all is
+ * TRUE when passed in), and -1 for Cancel. */
+int do_yesno_prompt(bool all, const char *msg)
+{
+    int ok = -2, width = 16;
+    const char *yesstr;		/* String of Yes characters accepted. */
+    const char *nostr;		/* Same for No. */
+    const char *allstr;		/* And All, surprise! */
+    const sc *s;
+    int oldmenu = currmenu;
+
+    assert(msg != NULL);
+
+    /* yesstr, nostr, and allstr are strings of any length.  Each string
+     * consists of all single-byte characters accepted as valid
+     * characters for that value.  The first value will be the one
+     * displayed in the shortcuts. */
+    /* TRANSLATORS: For the next three strings, if possible, specify
+     * the single-byte shortcuts for both your language and English.
+     * For example, in French: "OoYy" for "Oui". */
+    yesstr = _("Yy");
+    nostr = _("Nn");
+    allstr = _("Aa");
+
+    if (!ISSET(NO_HELP)) {
+	char shortstr[3];
+		/* Temp string for Yes, No, All. */
+
+	if (COLS < 32)
+	    width = COLS / 2;
+
+	/* Clear the shortcut list from the bottom of the screen. */
+	blank_bottombars();
+
+	sprintf(shortstr, " %c", yesstr[0]);
+	wmove(bottomwin, 1, 0);
+	onekey(shortstr, _("Yes"), width);
+
+	if (all) {
+	    wmove(bottomwin, 1, width);
+	    shortstr[1] = allstr[0];
+	    onekey(shortstr, _("All"), width);
+	}
+
+	wmove(bottomwin, 2, 0);
+	shortstr[1] = nostr[0];
+	onekey(shortstr, _("No"), width);
+
+	wmove(bottomwin, 2, 16);
+	onekey("^C", _("Cancel"), width);
+    }
+
+    wattron(bottomwin, reverse_attr);
+
+    blank_statusbar();
+    mvwaddnstr(bottomwin, 0, 0, msg, actual_x(msg, COLS - 1));
+
+     wattroff(bottomwin, reverse_attr);
+
+    /* Refresh the edit window and the statusbar before getting
+     * input. */
+    wnoutrefresh(edit);
+    wnoutrefresh(bottomwin);
+
+    do {
+	int kbinput;
+	bool meta_key, func_key;
+#ifndef DISABLE_MOUSE
+	int mouse_x, mouse_y;
+#endif
+
+	currmenu = MYESNO;
+	kbinput = get_kbinput(bottomwin, &meta_key, &func_key);
+	s = get_shortcut(currmenu, &kbinput, &meta_key, &func_key);
+
+	if (s && s->scfunc ==  do_cancel)
+	    ok = -1;
+#ifndef DISABLE_MOUSE
+	else if (kbinput == KEY_MOUSE) {
+		/* We can click on the Yes/No/All shortcut list to
+		 * select an answer. */
+		if (get_mouseinput(&mouse_x, &mouse_y, FALSE) == 0 &&
+			wmouse_trafo(bottomwin, &mouse_y, &mouse_x,
+			FALSE) && mouse_x < (width * 2) &&
+			mouse_y > 0) {
+		    int x = mouse_x / width;
+			/* Calculate the x-coordinate relative to the
+			 * two columns of the Yes/No/All shortcuts in
+			 * bottomwin. */
+		    int y = mouse_y - 1;
+			/* Calculate the y-coordinate relative to the
+			 * beginning of the Yes/No/All shortcuts in
+			 * bottomwin, i.e. with the sizes of topwin,
+			 * edit, and the first line of bottomwin
+			 * subtracted out. */
+
+		    assert(0 <= x && x <= 1 && 0 <= y && y <= 1);
+
+		    /* x == 0 means they clicked Yes or No.  y == 0
+		     * means Yes or All. */
+		    ok = -2 * x * y + x - y + 1;
+
+		    if (ok == 2 && !all)
+			ok = -2;
+		}
+	}
+#endif /* !DISABLE_MOUSE */
+	else if  (s && s->scfunc == total_refresh) {
+	    total_redraw();
+	    continue;
+	} else {
+		/* Look for the kbinput in the Yes, No and (optionally)
+		 * All strings. */
+		if (strchr(yesstr, kbinput) != NULL)
+		    ok = 1;
+		else if (strchr(nostr, kbinput) != NULL)
+		    ok = 0;
+		else if (all && strchr(allstr, kbinput) != NULL)
+		    ok = 2;
+	}
+    } while (ok == -2);
+
+    currmenu = oldmenu;
+    return ok;
+}
diff --git a/src/proto.h b/src/proto.h
new file mode 100644
index 0000000..38ebf6a
--- /dev/null
+++ b/src/proto.h
@@ -0,0 +1,863 @@
+/* $Id: proto.h 4530 2011-02-18 07:30:57Z astyanax $ */
+/**************************************************************************
+ *   proto.h                                                              *
+ *                                                                        *
+ *   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.                                                     *
+ *                                                                        *
+ **************************************************************************/
+
+#ifndef PROTO_H
+#define PROTO_H 1
+
+#include "nano.h"
+
+/* All external variables.  See global.c for their descriptions. */
+#ifndef NANO_TINY
+extern sigjmp_buf jump_buf;
+extern bool jump_buf_main;
+extern bool use_undo;
+#endif
+
+#ifndef DISABLE_WRAPJUSTIFY
+extern ssize_t fill;
+extern ssize_t wrap_at;
+#endif
+
+extern char *last_search;
+extern char *last_replace;
+
+extern unsigned flags[4];
+extern WINDOW *topwin;
+extern WINDOW *edit;
+extern WINDOW *bottomwin;
+extern int editwinrows;
+extern int maxrows;
+
+extern filestruct *cutbuffer;
+extern filestruct *cutbottom;
+#ifndef DISABLE_JUSTIFY
+extern filestruct *jusbuffer;
+#endif
+extern partition *filepart;
+extern openfilestruct *openfile;
+
+#ifndef NANO_TINY
+extern char *matchbrackets;
+#endif
+
+#if !defined(NANO_TINY) && defined(ENABLE_NANORC)
+extern char *whitespace;
+extern int whitespace_len[2];
+extern undo_type last_action;
+#endif
+
+#ifndef DISABLE_JUSTIFY
+extern char *punct;
+extern char *brackets;
+extern char *quotestr;
+#ifdef HAVE_REGEX_H
+extern regex_t quotereg;
+extern int quoterc;
+extern char *quoteerr;
+#else
+extern size_t quotelen;
+#endif
+#endif
+extern bool nodelay_mode;
+extern char *answer;
+
+extern ssize_t tabsize;
+
+#ifndef NANO_TINY
+extern char *backup_dir;
+#endif
+#ifndef DISABLE_OPERATINGDIR
+extern char *operating_dir;
+extern char *full_operating_dir;
+#endif
+
+#ifndef DISABLE_SPELLER
+extern char *alt_speller;
+#endif
+
+extern sc *sclist;
+extern subnfunc *allfuncs;
+#ifdef ENABLE_COLOR
+extern syntaxtype *syntaxes;
+extern char *syntaxstr;
+#endif
+
+extern bool edit_refresh_needed;
+extern const shortcut *currshortcut;
+extern int currmenu;
+
+#ifndef NANO_TINY
+extern filestruct *search_history;
+extern filestruct *searchage;
+extern filestruct *searchbot;
+extern filestruct *replace_history;
+extern filestruct *replaceage;
+extern filestruct *replacebot;
+extern poshiststruct *poshistory;
+void update_poshistory(char *filename, ssize_t lineno, ssize_t xpos);
+#endif
+
+#ifdef HAVE_REGEX_H
+extern regex_t search_regexp;
+extern regmatch_t regmatches[10];
+#endif
+
+extern int reverse_attr;
+
+extern char *homedir;
+
+/* All functions in browser.c. */
+#ifndef DISABLE_BROWSER
+char *do_browser(char *path, DIR *dir);
+char *do_browse_from(const char *inpath);
+void browser_init(const char *path, DIR *dir);
+void parse_browser_input(int *kbinput, bool *meta_key, bool *func_key);
+void browser_refresh(void);
+bool browser_select_filename(const char *needle);
+int filesearch_init(void);
+bool findnextfile(bool no_sameline, size_t begin, const char *needle);
+void findnextfile_wrap_reset(void);
+void filesearch_abort(void);
+void do_filesearch(void);
+void do_fileresearch(void);
+void do_first_file(void);
+void do_last_file(void);
+char *striponedir(const char *path);
+#endif
+
+/* All functions in chars.c. */
+#ifdef ENABLE_UTF8
+void utf8_init(void);
+bool using_utf8(void);
+#endif
+#ifndef HAVE_ISBLANK
+bool nisblank(int c);
+#endif
+#if !defined(HAVE_ISWBLANK) && defined(ENABLE_UTF8)
+bool niswblank(wchar_t wc);
+#endif
+bool is_byte(int c);
+bool is_alnum_mbchar(const char *c);
+bool is_blank_mbchar(const char *c);
+bool is_ascii_cntrl_char(int c);
+bool is_cntrl_char(int c);
+#ifdef ENABLE_UTF8
+bool is_cntrl_wchar(wchar_t wc);
+#endif
+bool is_cntrl_mbchar(const char *c);
+bool is_punct_mbchar(const char *c);
+bool is_word_mbchar(const char *c, bool allow_punct);
+char control_rep(char c);
+#ifdef ENABLE_UTF8
+wchar_t control_wrep(wchar_t c);
+#endif
+char *control_mbrep(const char *c, char *crep, int *crep_len);
+char *mbrep(const char *c, char *crep, int *crep_len);
+int mbwidth(const char *c);
+int mb_cur_max(void);
+char *make_mbchar(long chr, int *chr_mb_len);
+int parse_mbchar(const char *buf, char *chr, size_t *col);
+size_t move_mbleft(const char *buf, size_t pos);
+size_t move_mbright(const char *buf, size_t pos);
+#ifndef HAVE_STRCASECMP
+int nstrcasecmp(const char *s1, const char *s2);
+#endif
+int mbstrcasecmp(const char *s1, const char *s2);
+#ifndef HAVE_STRNCASECMP
+int nstrncasecmp(const char *s1, const char *s2, size_t n);
+#endif
+int mbstrncasecmp(const char *s1, const char *s2, size_t n);
+#ifndef HAVE_STRCASESTR
+char *nstrcasestr(const char *haystack, const char *needle);
+#endif
+char *mbstrcasestr(const char *haystack, const char *needle);
+#if !defined(NANO_TINY) || !defined(DISABLE_TABCOMP)
+char *revstrstr(const char *haystack, const char *needle, const char
+	*rev_start);
+#endif
+#ifndef NANO_TINY
+char *revstrcasestr(const char *haystack, const char *needle, const char
+	*rev_start);
+char *mbrevstrcasestr(const char *haystack, const char *needle, const
+	char *rev_start);
+#endif
+size_t mbstrlen(const char *s);
+#ifndef HAVE_STRNLEN
+size_t nstrnlen(const char *s, size_t maxlen);
+#endif
+size_t mbstrnlen(const char *s, size_t maxlen);
+#if !defined(NANO_TINY) || !defined(DISABLE_JUSTIFY)
+char *mbstrchr(const char *s, const char *c);
+#endif
+#ifndef NANO_TINY
+char *mbstrpbrk(const char *s, const char *accept);
+char *revstrpbrk(const char *s, const char *accept, const char
+	*rev_start);
+char *mbrevstrpbrk(const char *s, const char *accept, const char
+	*rev_start);
+#endif
+#if defined(ENABLE_NANORC) && (!defined(NANO_TINY) || !defined(DISABLE_JUSTIFY))
+bool has_blank_chars(const char *s);
+bool has_blank_mbchars(const char *s);
+#endif
+#ifdef ENABLE_UTF8
+bool is_valid_unicode(wchar_t wc);
+#endif
+#ifdef ENABLE_NANORC
+bool is_valid_mbstring(const char *s);
+#endif
+
+/* All functions in color.c. */
+#ifdef ENABLE_COLOR
+void set_colorpairs(void);
+void color_init(void);
+void color_update(void);
+#endif
+
+/* All functions in cut.c. */
+void cutbuffer_reset(void);
+void cut_line(void);
+#ifndef NANO_TINY
+void cut_marked(void);
+void cut_to_eol(void);
+void cut_to_eof(void);
+#endif
+void do_cut_text(
+#ifndef NANO_TINY
+	bool copy_text, bool cut_till_end, bool undoing
+#else
+	void
+#endif
+	);
+void do_cut_text_void(void);
+#ifndef NANO_TINY
+void do_copy_text(void);
+void do_cut_till_end(void);
+#endif
+void do_uncut_text(void);
+
+/* All functions in files.c. */
+void make_new_buffer(void);
+void initialize_buffer(void);
+void initialize_buffer_text(void);
+void open_buffer(const char *filename, bool undoable);
+#ifndef DISABLE_SPELLER
+void replace_buffer(const char *filename);
+#endif
+void display_buffer(void);
+#ifdef ENABLE_MULTIBUFFER
+void switch_to_prevnext_buffer(bool next);
+void switch_to_prev_buffer_void(void);
+void switch_to_next_buffer_void(void);
+bool close_buffer(void);
+#endif
+filestruct *read_line(char *buf, filestruct *prevnode, bool
+	*first_line_ins, size_t buf_len);
+void read_file(FILE *f, int fd, const char *filename, bool undoable, bool checkwritable);
+int open_file(const char *filename, bool newfie, FILE **f);
+char *get_next_filename(const char *name, const char *suffix);
+void do_insertfile(
+#ifndef NANO_TINY
+	bool execute
+#else
+	void
+#endif
+	);
+void do_insertfile_void(void);
+char *get_full_path(const char *origpath);
+char *check_writable_directory(const char *path);
+char *safe_tempfile(FILE **f);
+#ifndef DISABLE_OPERATINGDIR
+void init_operating_dir(void);
+bool check_operating_dir(const char *currpath, bool allow_tabcomp);
+#endif
+#ifndef NANO_TINY
+void init_backup_dir(void);
+#endif
+int copy_file(FILE *inn, FILE *out);
+bool write_file(const char *name, FILE *f_open, bool tmp, append_type
+	append, bool nonamechange);
+#ifndef NANO_TINY
+bool write_marked_file(const char *name, FILE *f_open, bool tmp,
+	append_type append);
+#endif
+bool do_writeout(bool exiting);
+void do_writeout_void(void);
+char *real_dir_from_tilde(const char *buf);
+#if !defined(DISABLE_TABCOMP) || !defined(DISABLE_BROWSER)
+int diralphasort(const void *va, const void *vb);
+void free_chararray(char **array, size_t len);
+#endif
+#ifndef DISABLE_TABCOMP
+bool is_dir(const char *buf);
+char **username_tab_completion(const char *buf, size_t *num_matches,
+	size_t buf_len);
+char **cwd_tab_completion(const char *buf, bool allow_files, size_t
+	*num_matches, size_t buf_len);
+char *input_tab(char *buf, bool allow_files, size_t *place, bool
+	*lastwastab, void (*refresh_func)(void), bool *list);
+#endif
+const char *tail(const char *foo);
+#if !defined(NANO_TINY) && defined(ENABLE_NANORC)
+char *histfilename(void);
+void load_history(void);
+bool writehist(FILE *hist, filestruct *histhead);
+void save_history(void);
+int check_dotnano(void);
+void load_poshistory(void);
+void save_poshistory(void);
+int check_poshistory(const char *file, ssize_t *line, ssize_t *column);
+#endif
+
+/* All functions in global.c. */
+size_t length_of_list(int menu);
+#ifndef NANO_TINY
+void toggle_init_one(int val
+#ifndef DISABLE_HELP
+	, const char *desc, bool blank_after
+#endif
+	, long flag);
+void toggle_init(void);
+#endif
+void sc_init_one(shortcut **shortcutage, int ctrlval, const char *desc
+#ifndef DISABLE_HELP
+	, const char *help, bool blank_after
+#endif
+	, int metaval, int funcval, int miscval, bool view, void
+	(*func)(void));
+void shortcut_init(bool unjustify);
+void free_shortcutage(shortcut **shortcutage);
+#ifdef DEBUG
+void thanks_for_all_the_fish(void);
+#endif
+
+/* All functions in help.c. */
+#ifndef DISABLE_BROWSER
+void do_browser_help(void);
+#endif
+void do_help_void(void);
+#ifndef DISABLE_HELP
+void do_help(void (*refresh_func)(void));
+void help_init(void);
+void parse_help_input(int *kbinput, bool *meta_key, bool *func_key);
+size_t help_line_len(const char *ptr);
+#endif
+
+/* All functions in move.c. */
+void do_first_line(void);
+void do_last_line(void);
+void do_page_up(void);
+void do_page_down(void);
+#ifndef DISABLE_JUSTIFY
+void do_para_begin(bool allow_update);
+void do_para_begin_void(void);
+void do_para_end(bool allow_update);
+void do_para_end_void(void);
+#endif
+#ifndef NANO_TINY
+bool do_next_word(bool allow_punct, bool allow_update);
+void do_next_word_void(void);
+bool do_prev_word(bool allow_punct, bool allow_update);
+void do_prev_word_void(void);
+#endif
+void do_home(void);
+void do_end(void);
+void do_up(
+#ifndef NANO_TINY
+	bool scroll_only
+#else
+	void
+#endif
+	);
+void do_up_void(void);
+#ifndef NANO_TINY
+void do_scroll_up(void);
+#endif
+void do_down(
+#ifndef NANO_TINY
+	bool scroll_only
+#else
+	void
+#endif
+	);
+void do_down_void(void);
+#ifndef NANO_TINY
+void do_scroll_down(void);
+#endif
+void do_left(void);
+void do_right(void);
+
+/* All functions in nano.c. */
+filestruct *make_new_node(filestruct *prevnode);
+filestruct *copy_node(const filestruct *src);
+void splice_node(filestruct *begin, filestruct *newnode, filestruct
+	*end);
+void unlink_node(const filestruct *fileptr);
+void delete_node(filestruct *fileptr);
+filestruct *copy_filestruct(const filestruct *src);
+void free_filestruct(filestruct *src);
+void renumber(filestruct *fileptr);
+partition *partition_filestruct(filestruct *top, size_t top_x,
+	filestruct *bot, size_t bot_x);
+void unpartition_filestruct(partition **p);
+void move_to_filestruct(filestruct **file_top, filestruct **file_bot,
+	filestruct *top, size_t top_x, filestruct *bot, size_t bot_x);
+void copy_from_filestruct(filestruct *file_top, filestruct *file_bot);
+openfilestruct *make_new_opennode(void);
+void splice_opennode(openfilestruct *begin, openfilestruct *newnode,
+	openfilestruct *end);
+void unlink_opennode(openfilestruct *fileptr);
+void delete_opennode(openfilestruct *fileptr);
+#ifdef DEBUG
+void free_openfilestruct(openfilestruct *src);
+#endif
+void print_view_warning(void);
+void finish(void);
+void die(const char *msg, ...);
+void die_save_file(const char *die_filename
+#ifndef NANO_TINY
+	, struct stat *die_stat
+#endif
+	);
+void window_init(void);
+#ifndef DISABLE_MOUSE
+void disable_mouse_support(void);
+void enable_mouse_support(void);
+void mouse_init(void);
+#endif
+void print_opt_full(const char *shortflag
+#ifdef HAVE_GETOPT_LONG
+	, const char *longflag
+#endif
+	, const char *desc);
+void usage(void);
+void version(void);
+int no_more_space(void);
+int no_help(void);
+void nano_disabled_msg(void);
+void do_exit(void);
+void signal_init(void);
+RETSIGTYPE handle_hupterm(int signal);
+RETSIGTYPE do_suspend(int signal);
+RETSIGTYPE do_continue(int signal);
+#ifndef NANO_TINY
+RETSIGTYPE handle_sigwinch(int signal);
+void allow_pending_sigwinch(bool allow);
+#endif
+#ifndef NANO_TINY
+void do_toggle(int flag);
+void do_toggle_void(void);
+#endif
+void disable_extended_io(void);
+#ifdef USE_SLANG
+void disable_signals(void);
+#endif
+#ifndef NANO_TINY
+void enable_signals(void);
+#endif
+void disable_flow_control(void);
+void enable_flow_control(void);
+void terminal_init(void);
+int do_input(bool *meta_key, bool *func_key, bool *have_shortcut, bool
+	*ran_func, bool *finished, bool allow_funcs);
+#ifndef DISABLE_MOUSE
+int do_mouse(void);
+#endif
+void do_output(char *output, size_t output_len, bool allow_cntrls);
+
+/* All functions in prompt.c. */
+int do_statusbar_input(bool *meta_key, bool *func_key, bool *have_shortcut,
+	bool *ran_func, bool *finished, bool allow_funcs, void
+	(*refresh_func)(void));
+#ifndef DISABLE_MOUSE
+int do_statusbar_mouse(void);
+#endif
+void do_statusbar_output(char *output, size_t output_len, bool
+	*got_enter, bool allow_cntrls);
+void do_statusbar_home(void);
+void do_statusbar_end(void);
+void do_statusbar_left(void);
+void do_statusbar_right(void);
+void do_statusbar_backspace(void);
+void do_statusbar_delete(void);
+void do_statusbar_cut_text(void);
+#ifndef NANO_TINY
+bool do_statusbar_next_word(bool allow_punct);
+bool do_statusbar_prev_word(bool allow_punct);
+#endif
+void do_statusbar_verbatim_input(bool *got_enter);
+#ifndef NANO_TINY
+bool find_statusbar_bracket_match(bool reverse, const char
+	*bracket_set);
+void do_statusbar_find_bracket(void);
+#endif
+size_t statusbar_xplustabs(void);
+size_t get_statusbar_page_start(size_t start_col, size_t column);
+void reset_statusbar_cursor(void);
+void update_statusbar_line(const char *curranswer, size_t index);
+bool need_statusbar_horizontal_update(size_t pww_save);
+void total_statusbar_refresh(void (*refresh_func)(void));
+const sc *get_prompt_string(int *value, bool allow_tabs,
+#ifndef DISABLE_TABCOMP
+	bool allow_files,
+#endif
+	const char *curranswer,
+	bool *meta_key, bool *func_key,
+#ifndef NANO_TINY
+	filestruct **history_list,
+#endif
+	void (*refresh_func)(void), int menu
+#ifndef DISABLE_TABCOMP
+	, bool *list
+#endif
+	);
+int do_prompt(bool allow_tabs,
+#ifndef DISABLE_TABCOMP
+	bool allow_files,
+#endif
+	int menu, const char *curranswer,
+	bool *meta_key, bool *func_key,
+#ifndef NANO_TINY
+	filestruct **history_list,
+#endif
+	void (*refresh_func)(void), const char *msg, ...);
+void do_prompt_abort(void);
+int do_yesno_prompt(bool all, const char *msg);
+
+/* All functions in rcfile.c. */
+#ifdef ENABLE_NANORC
+void rcfile_error(const char *msg, ...);
+char *parse_next_word(char *ptr);
+char *parse_argument(char *ptr);
+#ifdef ENABLE_COLOR
+char *parse_next_regex(char *ptr);
+bool nregcomp(const char *regex, int eflags);
+void parse_syntax(char *ptr);
+void parse_magic_syntax(char *ptr);
+void parse_include(char *ptr);
+short color_to_short(const char *colorname, bool *bright);
+void parse_colors(char *ptr, bool icase);
+void reset_multis(filestruct *fileptr, bool force);
+void alloc_multidata_if_needed(filestruct *fileptr);
+#endif
+void parse_rcfile(FILE *rcstream
+#ifdef ENABLE_COLOR
+	, bool syntax_only
+#endif
+	);
+void do_rcfile(void);
+#endif
+
+/* All functions in search.c. */
+#ifdef HAVE_REGEX_H
+bool regexp_init(const char *regexp);
+void regexp_cleanup(void);
+#endif
+void not_found_msg(const char *str);
+void search_replace_abort(void);
+void search_init_globals(void);
+int search_init(bool replacing, bool use_answer);
+bool findnextstr(
+#ifndef DISABLE_SPELLER
+	bool whole_word,
+#endif
+	bool no_sameline, const filestruct *begin, size_t begin_x, const
+	char *needle, size_t *needle_len);
+void findnextstr_wrap_reset(void);
+void do_search(void);
+#ifndef NANO_TINY
+void do_research(void);
+#endif
+#ifdef HAVE_REGEX_H
+int replace_regexp(char *string, bool create);
+#endif
+char *replace_line(const char *needle);
+ssize_t do_replace_loop(
+#ifndef DISABLE_SPELLER
+	bool whole_word,
+#endif
+	bool *canceled, const filestruct *real_current, size_t
+	*real_current_x, const char *needle);
+void do_replace(void);
+void do_gotolinecolumn(ssize_t line, ssize_t column, bool use_answer,
+	bool interactive, bool save_pos, bool allow_update);
+void do_gotolinecolumn_void(void);
+#ifndef DISABLE_SPELLER
+void do_gotopos(ssize_t pos_line, size_t pos_x, ssize_t pos_y, size_t
+	pos_pww);
+#endif
+#ifndef NANO_TINY
+bool find_bracket_match(bool reverse, const char *bracket_set);
+void do_find_bracket(void);
+#ifdef ENABLE_NANORC
+bool history_has_changed(void);
+#endif
+void history_init(void);
+void history_reset(const filestruct *h);
+filestruct *find_history(const filestruct *h_start, const filestruct
+	*h_end, const char *s, size_t len);
+void update_history(filestruct **h, const char *s);
+char *get_history_older(filestruct **h);
+char *get_history_newer(filestruct **h);
+void get_history_older_void(void);
+void get_history_newer_void(void);
+#ifndef DISABLE_TABCOMP
+char *get_history_completion(filestruct **h, const char *s, size_t len);
+#endif
+#endif
+
+/* All functions in text.c. */
+#ifndef NANO_TINY
+void do_mark(void);
+#endif
+void do_delete(void);
+void do_backspace(void);
+void do_tab(void);
+#ifndef NANO_TINY
+void do_indent(ssize_t cols);
+void do_indent_void(void);
+void do_unindent(void);
+void do_undo(void);
+void do_redo(void);
+#endif
+void do_enter(bool undoing);
+void do_enter_void(void);
+#ifndef NANO_TINY
+RETSIGTYPE cancel_command(int signal);
+bool execute_command(const char *command);
+#endif
+#ifndef DISABLE_WRAPPING
+void wrap_reset(void);
+bool do_wrap(filestruct *line, bool undoing);
+#endif
+#if !defined(DISABLE_HELP) || !defined(DISABLE_WRAPJUSTIFY)
+ssize_t break_line(const char *line, ssize_t goal
+#ifndef DISABLE_HELP
+	, bool newln
+#endif
+	);
+#endif
+#if !defined(NANO_TINY) || !defined(DISABLE_JUSTIFY)
+size_t indent_length(const char *line);
+#endif
+#ifndef DISABLE_JUSTIFY
+void justify_format(filestruct *paragraph, size_t skip);
+size_t quote_length(const char *line);
+bool quotes_match(const char *a_line, size_t a_quote, const char
+	*b_line);
+bool indents_match(const char *a_line, size_t a_indent, const char
+	*b_line, size_t b_indent);
+bool begpar(const filestruct *const foo);
+bool inpar(const filestruct *const foo);
+void backup_lines(filestruct *first_line, size_t par_len);
+bool find_paragraph(size_t *const quote, size_t *const par);
+void do_justify(bool full_justify);
+void do_justify_void(void);
+void do_full_justify(void);
+#endif
+#ifndef DISABLE_SPELLER
+bool do_int_spell_fix(const char *word);
+const char *do_int_speller(const char *tempfile_name);
+const char *do_alt_speller(char *tempfile_name);
+void do_spell(void);
+#endif
+#ifndef NANO_TINY
+void do_wordlinechar_count(void);
+#endif
+void do_verbatim_input(void);
+
+/* All functions in utils.c. */
+int digits(size_t n);
+void get_homedir(void);
+bool parse_num(const char *str, ssize_t *val);
+bool parse_line_column(const char *str, ssize_t *line, ssize_t *column);
+void align(char **str);
+void null_at(char **data, size_t index);
+void unsunder(char *str, size_t true_len);
+void sunder(char *str);
+#if !defined(NANO_TINY) && defined(ENABLE_NANORC)
+#ifndef HAVE_GETLINE
+ssize_t ngetline(char **lineptr, size_t *n, FILE *stream);
+#endif
+#ifndef HAVE_GETDELIM
+ssize_t ngetdelim(char **lineptr, size_t *n, int delim, FILE *stream);
+#endif
+#endif
+#ifdef HAVE_REGEX_H
+bool regexp_bol_or_eol(const regex_t *preg, const char *string);
+const char *fixbounds(const char *r);
+#endif
+#ifndef DISABLE_SPELLER
+bool is_whole_word(size_t pos, const char *buf, const char *word);
+#endif
+const char *strstrwrapper(const char *haystack, const char *needle,
+	const char *start);
+void nperror(const char *s);
+void *nmalloc(size_t howmuch);
+void *nrealloc(void *ptr, size_t howmuch);
+char *mallocstrncpy(char *dest, const char *src, size_t n);
+char *mallocstrcpy(char *dest, const char *src);
+char *mallocstrassn(char *dest, char *src);
+size_t get_page_start(size_t column);
+size_t xplustabs(void);
+size_t actual_x(const char *s, size_t column);
+size_t strnlenpt(const char *s, size_t maxlen);
+size_t strlenpt(const char *s);
+void new_magicline(void);
+#ifndef NANO_TINY
+void remove_magicline(void);
+void mark_order(const filestruct **top, size_t *top_x, const filestruct
+	**bot, size_t *bot_x, bool *right_side_up);
+void add_undo(undo_type current_action);
+void update_undo(undo_type action);
+#endif
+size_t get_totsize(const filestruct *begin, const filestruct *end);
+filestruct *fsfromline(ssize_t lineno);
+#ifdef DEBUG
+void dump_filestruct(const filestruct *inptr);
+void dump_filestruct_reverse(void);
+#endif
+
+/* All functions in winio.c. */
+void get_key_buffer(WINDOW *win);
+size_t get_key_buffer_len(void);
+void unget_input(int *input, size_t input_len);
+void unget_kbinput(int kbinput, bool meta_key, bool func_key);
+int *get_input(WINDOW *win, size_t input_len);
+int get_kbinput(WINDOW *win, bool *meta_key, bool *func_key);
+int parse_kbinput(WINDOW *win, bool *meta_key, bool *func_key);
+int get_escape_seq_kbinput(const int *seq, size_t seq_len);
+int get_escape_seq_abcd(int kbinput);
+int parse_escape_seq_kbinput(WINDOW *win, int kbinput);
+int get_byte_kbinput(int kbinput);
+#ifdef ENABLE_UTF8
+long add_unicode_digit(int kbinput, long factor, long *uni);
+long get_unicode_kbinput(int kbinput);
+#endif
+int get_control_kbinput(int kbinput);
+void unparse_kbinput(char *output, size_t output_len);
+int *get_verbatim_kbinput(WINDOW *win, size_t *kbinput_len);
+int *parse_verbatim_kbinput(WINDOW *win, size_t *kbinput_len);
+#ifndef DISABLE_MOUSE
+int get_mouseinput(int *mouse_x, int *mouse_y, bool allow_shortcuts);
+#endif
+const sc *get_shortcut(int menu, int *kbinput, bool
+	*meta_key, bool *func_key);
+const sc *first_sc_for(int menu, void (*func)(void));
+void blank_line(WINDOW *win, int y, int x, int n);
+void blank_titlebar(void);
+void blank_topbar(void);
+void blank_edit(void);
+void blank_statusbar(void);
+void blank_bottombars(void);
+void check_statusblank(void);
+char *display_string(const char *buf, size_t start_col, size_t len, bool
+	dollars);
+void titlebar(const char *path);
+void set_modified(void);
+void statusbar(const char *msg, ...);
+void bottombars(int menu);
+void onekey(const char *keystroke, const char *desc, size_t len);
+void reset_cursor(void);
+void edit_draw(filestruct *fileptr, const char *converted, int
+	line, size_t start);
+int update_line(filestruct *fileptr, size_t index);
+bool need_horizontal_update(size_t pww_save);
+bool need_vertical_update(size_t pww_save);
+void edit_scroll(scroll_dir direction, ssize_t nlines);
+void edit_redraw(filestruct *old_current, size_t pww_save);
+void edit_refresh(void);
+void edit_update(update_type location);
+void total_redraw(void);
+void total_refresh(void);
+void display_main_list(void);
+void do_cursorpos(bool constant);
+void do_cursorpos_void(void);
+void do_replace_highlight(bool highlight, const char *word);
+const char *flagtostr(int flag);
+const subnfunc *sctofunc(sc *s);
+const subnfunc *getfuncfromkey(WINDOW *win);
+void print_sclist(void);
+sc *strtosc(int menu, char *input);
+function_type strtokeytype(const char *str);
+int strtomenu(char *input);
+void assign_keyinfo(sc *s);
+void xon_complaint(void);
+void xoff_complaint(void);
+int sc_seq_or (void (*func)(void), int defaultval);
+void do_suspend_void(void);
+
+extern const char *cancel_msg;
+#ifndef NANO_TINY
+extern const char *case_sens_msg;
+extern const char *backwards_msg;
+extern const char *prev_history_msg;
+extern const char *next_history_msg;
+#endif
+extern const char *replace_msg;
+extern const char *no_replace_msg;
+extern const char *go_to_line_msg;
+extern const char *whereis_next_msg;
+extern const char *first_file_msg;
+extern const char *last_file_msg;
+extern const char *goto_dir_msg;
+extern const char *ext_cmd_msg;
+extern const char *to_files_msg;
+extern const char *dos_format_msg;
+extern const char *mac_format_msg;
+extern const char *append_msg;
+extern const char *prepend_msg;
+extern const char *backup_file_msg;
+extern const char *gototext_msg;
+extern const char *new_buffer_msg;
+
+void enable_nodelay(void);
+void disable_nodelay(void);
+
+#ifdef HAVE_REGEX_H
+extern const char *regexp_msg;
+#endif
+
+#ifdef NANO_EXTRA
+void do_credits(void);
+#endif
+
+/* May as just throw these here since they are just placeholders */
+void do_cancel(void);
+void case_sens_void(void);
+void regexp_void(void);
+void gototext_void(void);
+void to_files_void(void);
+void dos_format_void(void);
+void mac_format_void(void);
+void append_void(void);
+void prepend_void(void);
+void backup_file_void(void);
+void new_buffer_void(void);
+void backwards_void(void);
+void goto_dir_void(void);
+void no_replace_void(void);
+void ext_cmd_void(void);
+
+
+#endif /* !PROTO_H */
diff --git a/src/rcfile.c b/src/rcfile.c
new file mode 100644
index 0000000..f5e507a
--- /dev/null
+++ b/src/rcfile.c
@@ -0,0 +1,1305 @@
+/* $Id: rcfile.c 4530 2011-02-18 07:30:57Z astyanax $ */
+/**************************************************************************
+ *   rcfile.c                                                             *
+ *                                                                        *
+ *   Copyright (C) 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 <stdarg.h>
+#include <string.h>
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+#include <ctype.h>
+
+#ifdef ENABLE_NANORC
+
+static const rcoption rcopts[] = {
+    {"boldtext", BOLD_TEXT},
+#ifndef DISABLE_JUSTIFY
+    {"brackets", 0},
+#endif
+    {"const", CONST_UPDATE},
+#ifndef DISABLE_WRAPJUSTIFY
+    {"fill", 0},
+#endif
+#ifndef DISABLE_MOUSE
+    {"mouse", USE_MOUSE},
+#endif
+#ifdef ENABLE_MULTIBUFFER
+    {"multibuffer", MULTIBUFFER},
+#endif
+    {"morespace", MORE_SPACE},
+    {"nofollow", NOFOLLOW_SYMLINKS},
+    {"nohelp", NO_HELP},
+    {"nonewlines", NO_NEWLINES},
+#ifndef DISABLE_WRAPPING
+    {"nowrap", NO_WRAP},
+#endif
+#ifndef DISABLE_OPERATINGDIR
+    {"operatingdir", 0},
+#endif
+    {"preserve", PRESERVE},
+#ifndef DISABLE_JUSTIFY
+    {"punct", 0},
+    {"quotestr", 0},
+#endif
+    {"rebinddelete", REBIND_DELETE},
+    {"rebindkeypad", REBIND_KEYPAD},
+#ifdef HAVE_REGEX_H
+    {"regexp", USE_REGEXP},
+#endif
+#ifndef DISABLE_SPELLER
+    {"speller", 0},
+#endif
+    {"suspend", SUSPEND},
+    {"tabsize", 0},
+    {"tempfile", TEMP_FILE},
+    {"view", VIEW_MODE},
+#ifndef NANO_TINY
+    {"autoindent", AUTOINDENT},
+    {"backup", BACKUP_FILE},
+    {"allow_insecure_backup", INSECURE_BACKUP},
+    {"backupdir", 0},
+    {"backwards", BACKWARDS_SEARCH},
+    {"casesensitive", CASE_SENSITIVE},
+    {"cut", CUT_TO_END},
+    {"historylog", HISTORYLOG},
+    {"matchbrackets", 0},
+    {"noconvert", NO_CONVERT},
+    {"poslog", POS_HISTORY},
+    {"quiet", QUIET},
+    {"quickblank", QUICK_BLANK},
+    {"smarthome", SMART_HOME},
+    {"smooth", SMOOTH_SCROLL},
+    {"tabstospaces", TABS_TO_SPACES},
+    {"undo", UNDOABLE},
+    {"whitespace", 0},
+    {"wordbounds", WORD_BOUNDS},
+    {"softwrap", SOFTWRAP},
+#endif
+    {NULL, 0}
+};
+
+static bool errors = FALSE;
+	/* Whether we got any errors while parsing an rcfile. */
+static size_t lineno = 0;
+	/* If we did, the line number where the last error occurred. */
+static char *nanorc = NULL;
+	/* The path to the rcfile we're parsing. */
+#ifdef ENABLE_COLOR
+static syntaxtype *endsyntax = NULL;
+	/* The end of the list of syntaxes. */
+static exttype *endheader = NULL;
+	/* End of header list */
+static colortype *endcolor = NULL;
+	/* The end of the color list for the current syntax. */
+
+#endif
+
+/* We have an error in some part of the rcfile.  Print the error message
+ * on stderr, and then make the user hit Enter to continue starting
+ * nano. */
+void rcfile_error(const char *msg, ...)
+{
+    va_list ap;
+
+    if (ISSET(QUIET))
+	return;
+
+    fprintf(stderr, "\n");
+    if (lineno > 0) {
+	errors = TRUE;
+	fprintf(stderr, _("Error in %s on line %lu: "), nanorc, (unsigned long)lineno);
+    }
+
+    va_start(ap, msg);
+    vfprintf(stderr, _(msg), ap);
+    va_end(ap);
+
+    fprintf(stderr, "\n");
+}
+
+/* Parse the next word from the string, null-terminate it, and return
+ * a pointer to the first character after the null terminator.  The
+ * returned pointer will point to '\0' if we hit the end of the line. */
+char *parse_next_word(char *ptr)
+{
+    while (!isblank(*ptr) && *ptr != '\0')
+	ptr++;
+
+    if (*ptr == '\0')
+	return ptr;
+
+    /* Null-terminate and advance ptr. */
+    *ptr++ = '\0';
+
+    while (isblank(*ptr))
+	ptr++;
+
+    return ptr;
+}
+
+/* Parse an argument, with optional quotes, after a keyword that takes
+ * one.  If the next word starts with a ", we say that it ends with the
+ * last " of the line.  Otherwise, we interpret it as usual, so that the
+ * arguments can contain "'s too. */
+char *parse_argument(char *ptr)
+{
+    const char *ptr_save = ptr;
+    char *last_quote = NULL;
+
+    assert(ptr != NULL);
+
+    if (*ptr != '"')
+	return parse_next_word(ptr);
+
+    do {
+	ptr++;
+	if (*ptr == '"')
+	    last_quote = ptr;
+    } while (*ptr != '\0');
+
+    if (last_quote == NULL) {
+	if (*ptr == '\0')
+	    ptr = NULL;
+	else
+	    *ptr++ = '\0';
+	rcfile_error(N_("Argument '%s' has an unterminated \""), ptr_save);
+    } else {
+	*last_quote = '\0';
+	ptr = last_quote + 1;
+    }
+    if (ptr != NULL)
+	while (isblank(*ptr))
+	    ptr++;
+    return ptr;
+}
+
+#ifdef ENABLE_COLOR
+/* Parse the next regex string from the line at ptr, and return it. */
+char *parse_next_regex(char *ptr)
+{
+    assert(ptr != NULL);
+
+    /* Continue until the end of the line, or a " followed by a space, a
+     * blank character, or \0. */
+    while ((*ptr != '"' || (!isblank(*(ptr + 1)) &&
+	*(ptr + 1) != '\0')) && *ptr != '\0')
+	ptr++;
+
+    assert(*ptr == '"' || *ptr == '\0');
+
+    if (*ptr == '\0') {
+	rcfile_error(
+		N_("Regex strings must begin and end with a \" character"));
+	return NULL;
+    }
+
+    /* Null-terminate and advance ptr. */
+    *ptr++ = '\0';
+
+    while (isblank(*ptr))
+	ptr++;
+
+    return ptr;
+}
+
+/* Compile the regular expression regex to see if it's valid.  Return
+ * TRUE if it is, or FALSE otherwise. */
+bool nregcomp(const char *regex, int eflags)
+{
+    regex_t preg;
+    const char *r = fixbounds(regex);
+    int rc = regcomp(&preg, r, REG_EXTENDED | eflags);
+
+    if (rc != 0) {
+	size_t len = regerror(rc, &preg, NULL, 0);
+	char *str = charalloc(len);
+
+	regerror(rc, &preg, str, len);
+	rcfile_error(N_("Bad regex \"%s\": %s"), r, str);
+	free(str);
+    }
+
+    regfree(&preg);
+    return (rc == 0);
+}
+
+/* Parse the next syntax string from the line at ptr, and add it to the
+ * global list of color syntaxes. */
+void parse_syntax(char *ptr)
+{
+    const char *fileregptr = NULL, *nameptr = NULL;
+    syntaxtype *tmpsyntax;
+    exttype *endext = NULL;
+	/* The end of the extensions list for this syntax. */
+
+    assert(ptr != NULL);
+
+    if (*ptr == '\0') {
+	rcfile_error(N_("Missing syntax name"));
+	return;
+    }
+
+    if (*ptr != '"') {
+	rcfile_error(
+		N_("Regex strings must begin and end with a \" character"));
+	return;
+    }
+
+    ptr++;
+
+    nameptr = ptr;
+    ptr = parse_next_regex(ptr);
+
+    if (ptr == NULL)
+	return;
+
+    /* Search for a duplicate syntax name.  If we find one, free it, so
+     * that we always use the last syntax with a given name. */
+    for (tmpsyntax = syntaxes; tmpsyntax != NULL;
+	tmpsyntax = tmpsyntax->next) {
+	if (strcmp(nameptr, tmpsyntax->desc) == 0) {
+	    syntaxtype *prev_syntax = tmpsyntax;
+
+	    tmpsyntax = tmpsyntax->next;
+	    free(prev_syntax);
+	    break;
+	}
+    }
+
+    if (syntaxes == NULL) {
+	syntaxes = (syntaxtype *)nmalloc(sizeof(syntaxtype));
+	endsyntax = syntaxes;
+    } else {
+	endsyntax->next = (syntaxtype *)nmalloc(sizeof(syntaxtype));
+	endsyntax = endsyntax->next;
+#ifdef DEBUG
+	fprintf(stderr, "Adding new syntax after first one\n");
+#endif
+    }
+
+    endsyntax->desc = mallocstrcpy(NULL, nameptr);
+    endsyntax->color = NULL;
+    endcolor = NULL;
+    endheader = NULL;
+    endsyntax->extensions = NULL;
+    endsyntax->headers = NULL;
+    endsyntax->magics = NULL;
+    endsyntax->next = NULL;
+    endsyntax->nmultis = 0;
+
+#ifdef DEBUG
+    fprintf(stderr, "Starting a new syntax type: \"%s\"\n", nameptr);
+#endif
+
+    /* The "none" syntax is the same as not having a syntax at all, so
+     * we can't assign any extensions or colors to it. */
+    if (strcmp(endsyntax->desc, "none") == 0) {
+	rcfile_error(N_("The \"none\" syntax is reserved"));
+	return;
+    }
+
+    /* The default syntax should have no associated extensions. */
+    if (strcmp(endsyntax->desc, "default") == 0 && *ptr != '\0') {
+	rcfile_error(
+		N_("The \"default\" syntax must take no extensions"));
+	return;
+    }
+
+    /* Now load the extensions into their part of the struct. */
+    while (*ptr != '\0') {
+	exttype *newext;
+	    /* The new extension structure. */
+
+	while (*ptr != '"' && *ptr != '\0')
+	    ptr++;
+
+	if (*ptr == '\0')
+	    return;
+
+	ptr++;
+
+	fileregptr = ptr;
+	ptr = parse_next_regex(ptr);
+	if (ptr == NULL)
+	    break;
+
+	newext = (exttype *)nmalloc(sizeof(exttype));
+
+	/* Save the extension regex if it's valid. */
+	if (nregcomp(fileregptr, REG_NOSUB)) {
+	    newext->ext_regex = mallocstrcpy(NULL, fileregptr);
+	    newext->ext = NULL;
+
+	    if (endext == NULL)
+		endsyntax->extensions = newext;
+	    else
+		endext->next = newext;
+	    endext = newext;
+	    endext->next = NULL;
+	} else
+	    free(newext);
+    }
+
+}
+
+
+/* Parse the next syntax string from the line at ptr, and add it to the
+ * global list of color syntaxes. */
+void parse_magictype(char *ptr)
+{
+#ifdef HAVE_LIBMAGIC
+    const char *fileregptr = NULL;
+    exttype *endext = NULL;
+
+    assert(ptr != NULL);
+
+    if (syntaxes == NULL) {
+	rcfile_error(
+		N_("Cannot add a magic string regex without a syntax command"));
+	return;
+    }
+
+    if (*ptr == '\0') {
+	rcfile_error(N_("Missing magic string name"));
+	return;
+    }
+
+    if (*ptr != '"') {
+	rcfile_error(
+		N_("Regex strings must begin and end with a \" character"));
+	return;
+    }
+
+#ifdef DEBUG
+    fprintf(stderr, "Starting a magic type: \"%s\"\n", ptr);
+#endif
+
+    /* Now load the extensions into their part of the struct. */
+    while (*ptr != '\0') {
+	exttype *newext;
+	    /* The new extension structure. */
+
+	while (*ptr != '"' && *ptr != '\0')
+	    ptr++;
+
+	if (*ptr == '\0')
+	    return;
+
+	ptr++;
+
+	fileregptr = ptr;
+	ptr = parse_next_regex(ptr);
+	if (ptr == NULL)
+	    break;
+
+	newext = (exttype *)nmalloc(sizeof(exttype));
+
+	/* Save the regex if it's valid. */
+	if (nregcomp(fileregptr, REG_NOSUB)) {
+	    newext->ext_regex = mallocstrcpy(NULL, fileregptr);
+	    newext->ext = NULL;
+
+	    if (endext == NULL)
+		endsyntax->magics = newext;
+	    else
+		endext->next = newext;
+	    endext = newext;
+	    endext->next = NULL;
+	} else
+	    free(newext);
+    }
+#endif /* HAVE_LIBMAGIC */
+}
+
+int check_bad_binding(sc *s)
+{
+#define BADLISTLEN 1
+    int badtypes[BADLISTLEN] = {META};
+    int badseqs[BADLISTLEN] = { 91 };
+    int i;
+
+    for (i = 0; i < BADLISTLEN; i++)
+        if (s->type == badtypes[i] && s->seq == badseqs[i])
+	    return 1;
+
+    return 0;
+}
+
+void parse_keybinding(char *ptr)
+{
+    char *keyptr = NULL, *keycopy = NULL, *funcptr = NULL, *menuptr = NULL;
+    sc *s, *newsc;
+    int i, menu;
+
+    assert(ptr != NULL);
+
+    if (*ptr == '\0') {
+	rcfile_error(N_("Missing key name"));
+	return;
+    }
+
+    keyptr = ptr;
+    ptr = parse_next_word(ptr);
+    keycopy = mallocstrcpy(NULL, keyptr);
+    for (i = 0; i < strlen(keycopy); i++)
+	keycopy[i] = toupper(keycopy[i]);
+
+    if (keycopy[0] != 'M' && keycopy[0] != '^' && keycopy[0] != 'F' && keycopy[0] != 'K') {
+	rcfile_error(
+		N_("keybindings must begin with \"^\", \"M\", or \"F\""));
+	return;
+    }
+
+    funcptr = ptr;
+    ptr = parse_next_word(ptr);
+
+    if (!strcmp(funcptr, "")) {
+	rcfile_error(
+		N_("Must specify function to bind key to"));
+	return;
+    }
+
+    menuptr = ptr;
+    ptr = parse_next_word(ptr);
+
+    if (!strcmp(menuptr, "")) {
+	rcfile_error(
+		/* Note to translators, do not translate the word "all"
+		   in the sentence below, everything else is fine */
+		N_("Must specify menu to bind key to (or \"all\")"));
+	return;
+    }
+
+    menu = strtomenu(menuptr);
+    newsc = strtosc(menu, funcptr);
+    if (newsc == NULL) {
+	rcfile_error(
+		N_("Could not map name \"%s\" to a function"), funcptr);
+	return;
+    }
+
+    if (menu < 1) {
+	rcfile_error(
+		N_("Could not map name \"%s\" to a menu"), menuptr);
+	return;
+    }
+
+
+#ifdef DEBUG
+    fprintf(stderr, "newsc now address %d, menu func assigned = %d, menu = %d\n",
+	&newsc, newsc->scfunc, menu);
+#endif
+
+
+    newsc->keystr = keycopy;
+    newsc->menu = menu;
+    newsc->type = strtokeytype(newsc->keystr);
+    assign_keyinfo(newsc);
+#ifdef DEBUG
+    fprintf(stderr, "s->keystr = \"%s\"\n", newsc->keystr);
+    fprintf(stderr, "s->seq = \"%d\"\n", newsc->seq);
+#endif
+
+    if (check_bad_binding(newsc)) {
+	rcfile_error(
+		N_("Sorry, keystr \"%s\" is an illegal binding"), newsc->keystr);
+	return;
+    }
+
+    /* now let's have some fun.  Try and delete the other entries
+       we found for the same menu, then make this new new
+       beginning */
+    for (s = sclist; s != NULL; s = s->next) {
+        if (((s->menu & newsc->menu)) && s->seq == newsc->seq) {
+	    s->menu &= ~newsc->menu;
+#ifdef DEBUG
+	    fprintf(stderr, "replaced menu entry %d\n", s->menu);
+#endif
+	}
+    }
+    newsc->next = sclist;
+    sclist = newsc;
+}
+
+/* Let user unbind a sequence from a given (or all) menus */
+void parse_unbinding(char *ptr)
+{
+    char *keyptr = NULL, *keycopy = NULL, *menuptr = NULL;
+    sc *s;
+    int i, menu;
+
+    assert(ptr != NULL);
+
+    if (*ptr == '\0') {
+	rcfile_error(N_("Missing key name"));
+	return;
+    }
+
+    keyptr = ptr;
+    ptr = parse_next_word(ptr);
+    keycopy = mallocstrcpy(NULL, keyptr);
+    for (i = 0; i < strlen(keycopy); i++)
+	keycopy[i] = toupper(keycopy[i]);
+
+#ifdef DEBUG
+    fprintf(stderr, "Starting unbinding code");
+#endif
+
+    if (keycopy[0] != 'M' && keycopy[0] != '^' && keycopy[0] != 'F' && keycopy[0] != 'K') {
+	rcfile_error(
+		N_("keybindings must begin with \"^\", \"M\", or \"F\""));
+	return;
+    }
+
+    menuptr = ptr;
+    ptr = parse_next_word(ptr);
+
+    if (!strcmp(menuptr, "")) {
+	rcfile_error(
+		/* Note to translators, do not translate the word "all"
+		   in the sentence below, everything else is fine */
+		N_("Must specify menu to bind key to (or \"all\")"));
+	return;
+    }
+
+    menu = strtomenu(menuptr);
+    if (menu < 1) {
+	rcfile_error(
+		N_("Could not map name \"%s\" to a menu"), menuptr);
+	return;
+    }
+
+
+#ifdef DEBUG
+    fprintf(stderr, "unbinding \"%s\" from menu = %d\n", keycopy, menu);
+#endif
+
+    /* Now find the apropriate entries in the menu to delete */
+    for (s = sclist; s != NULL; s = s->next) {
+        if (((s->menu & menu)) && !strcmp(s->keystr,keycopy)) {
+	    s->menu &= ~menu;
+#ifdef DEBUG
+	    fprintf(stderr, "deleted menu entry %d\n", s->menu);
+#endif
+	}
+    }
+}
+
+
+/* Read and parse additional syntax files. */
+void parse_include(char *ptr)
+{
+    struct stat rcinfo;
+    FILE *rcstream;
+    char *option, *nanorc_save = nanorc, *expanded;
+    size_t lineno_save = lineno;
+
+    option = ptr;
+    if (*option == '"')
+	option++;
+    ptr = parse_argument(ptr);
+
+    /* Can't get the specified file's full path cause it may screw up
+	our cwd depending on the parent dirs' permissions, (see Savannah bug 25297) */
+
+    /* Don't open directories, character files, or block files. */
+    if (stat(option, &rcinfo) != -1) {
+	if (S_ISDIR(rcinfo.st_mode) || S_ISCHR(rcinfo.st_mode) ||
+		S_ISBLK(rcinfo.st_mode)) {
+	    rcfile_error(S_ISDIR(rcinfo.st_mode) ?
+		_("\"%s\" is a directory") :
+		_("\"%s\" is a device file"), option);
+	}
+    }
+
+    expanded = real_dir_from_tilde(option);
+
+    /* Open the new syntax file. */
+    if ((rcstream = fopen(expanded, "rb")) == NULL) {
+	rcfile_error(_("Error reading %s: %s"), expanded,
+		strerror(errno));
+	return;
+    }
+
+    /* Use the name and line number position of the new syntax file
+     * while parsing it, so we can know where any errors in it are. */
+    nanorc = expanded;
+    lineno = 0;
+
+#ifdef DEBUG
+    fprintf(stderr, "Parsing file \"%s\" (expanded from \"%s\")\n", expanded, option);
+#endif
+
+    parse_rcfile(rcstream
+#ifdef ENABLE_COLOR
+	, TRUE
+#endif
+	);
+
+    /* We're done with the new syntax file.  Restore the original
+     * filename and line number position. */
+    nanorc = nanorc_save;
+    lineno = lineno_save;
+
+}
+
+/* Return the short value corresponding to the color named in colorname,
+ * and set bright to TRUE if that color is bright. */
+short color_to_short(const char *colorname, bool *bright)
+{
+    short mcolor = -1;
+
+    assert(colorname != NULL && bright != NULL);
+
+    if (strncasecmp(colorname, "bright", 6) == 0) {
+	*bright = TRUE;
+	colorname += 6;
+    }
+
+    if (strcasecmp(colorname, "green") == 0)
+	mcolor = COLOR_GREEN;
+    else if (strcasecmp(colorname, "red") == 0)
+	mcolor = COLOR_RED;
+    else if (strcasecmp(colorname, "blue") == 0)
+	mcolor = COLOR_BLUE;
+    else if (strcasecmp(colorname, "white") == 0)
+	mcolor = COLOR_WHITE;
+    else if (strcasecmp(colorname, "yellow") == 0)
+	mcolor = COLOR_YELLOW;
+    else if (strcasecmp(colorname, "cyan") == 0)
+	mcolor = COLOR_CYAN;
+    else if (strcasecmp(colorname, "magenta") == 0)
+	mcolor = COLOR_MAGENTA;
+    else if (strcasecmp(colorname, "black") == 0)
+	mcolor = COLOR_BLACK;
+    else
+	rcfile_error(N_("Color \"%s\" not understood.\n"
+		"Valid colors are \"green\", \"red\", \"blue\",\n"
+		"\"white\", \"yellow\", \"cyan\", \"magenta\" and\n"
+		"\"black\", with the optional prefix \"bright\"\n"
+		"for foreground colors."), colorname);
+
+    return mcolor;
+}
+
+/* Parse the color string in the line at ptr, and add it to the current
+ * file's associated colors.  If icase is TRUE, treat the color string
+ * as case insensitive. */
+void parse_colors(char *ptr, bool icase)
+{
+    short fg, bg;
+    bool bright = FALSE, no_fgcolor = FALSE;
+    char *fgstr;
+
+    assert(ptr != NULL);
+
+    if (syntaxes == NULL) {
+	rcfile_error(
+		N_("Cannot add a color command without a syntax command"));
+	return;
+    }
+
+    if (*ptr == '\0') {
+	rcfile_error(N_("Missing color name"));
+	return;
+    }
+
+    fgstr = ptr;
+    ptr = parse_next_word(ptr);
+
+    if (strchr(fgstr, ',') != NULL) {
+	char *bgcolorname;
+
+	strtok(fgstr, ",");
+	bgcolorname = strtok(NULL, ",");
+	if (bgcolorname == NULL) {
+	    /* If we have a background color without a foreground color,
+	     * parse it properly. */
+	    bgcolorname = fgstr + 1;
+	    no_fgcolor = TRUE;
+	}
+	if (strncasecmp(bgcolorname, "bright", 6) == 0) {
+	    rcfile_error(
+		N_("Background color \"%s\" cannot be bright"),
+		bgcolorname);
+	    return;
+	}
+	bg = color_to_short(bgcolorname, &bright);
+    } else
+	bg = -1;
+
+    if (!no_fgcolor) {
+	fg = color_to_short(fgstr, &bright);
+
+	/* Don't try to parse screwed-up foreground colors. */
+	if (fg == -1)
+	    return;
+    } else
+	fg = -1;
+
+    if (*ptr == '\0') {
+	rcfile_error(N_("Missing regex string"));
+	return;
+    }
+
+    /* Now for the fun part.  Start adding regexes to individual strings
+     * in the colorstrings array, woo! */
+    while (ptr != NULL && *ptr != '\0') {
+	colortype *newcolor;
+	    /* The new color structure. */
+	bool cancelled = FALSE;
+	    /* The start expression was bad. */
+	bool expectend = FALSE;
+	    /* Do we expect an end= line? */
+
+	if (strncasecmp(ptr, "start=", 6) == 0) {
+	    ptr += 6;
+	    expectend = TRUE;
+	}
+
+	if (*ptr != '"') {
+	    rcfile_error(
+		N_("Regex strings must begin and end with a \" character"));
+	    ptr = parse_next_regex(ptr);
+	    continue;
+	}
+
+	ptr++;
+
+	fgstr = ptr;
+	ptr = parse_next_regex(ptr);
+	if (ptr == NULL)
+	    break;
+
+	newcolor = (colortype *)nmalloc(sizeof(colortype));
+
+	/* Save the starting regex string if it's valid, and set up the
+	 * color information. */
+	if (nregcomp(fgstr, icase ? REG_ICASE : 0)) {
+	    newcolor->fg = fg;
+	    newcolor->bg = bg;
+	    newcolor->bright = bright;
+	    newcolor->icase = icase;
+
+	    newcolor->start_regex = mallocstrcpy(NULL, fgstr);
+	    newcolor->start = NULL;
+
+	    newcolor->end_regex = NULL;
+	    newcolor->end = NULL;
+
+	    newcolor->next = NULL;
+
+	    if (endcolor == NULL) {
+		endsyntax->color = newcolor;
+#ifdef DEBUG
+		fprintf(stderr, "Starting a new colorstring for fg %hd, bg %hd\n", fg, bg);
+#endif
+	    } else {
+#ifdef DEBUG
+		fprintf(stderr, "Adding new entry for fg %hd, bg %hd\n", fg, bg);
+#endif
+		endcolor->next = newcolor;
+	    }
+
+	    endcolor = newcolor;
+	} else {
+	    free(newcolor);
+	    cancelled = TRUE;
+	}
+
+	if (expectend) {
+	    if (ptr == NULL || strncasecmp(ptr, "end=", 4) != 0) {
+		rcfile_error(
+			N_("\"start=\" requires a corresponding \"end=\""));
+		return;
+	    }
+	    ptr += 4;
+	    if (*ptr != '"') {
+		rcfile_error(
+			N_("Regex strings must begin and end with a \" character"));
+		continue;
+	    }
+
+	    ptr++;
+
+	    fgstr = ptr;
+	    ptr = parse_next_regex(ptr);
+	    if (ptr == NULL)
+		break;
+
+	    /* If the start regex was invalid, skip past the end regex to
+	     * stay in sync. */
+	    if (cancelled)
+		continue;
+
+	    /* Save the ending regex string if it's valid. */
+	    newcolor->end_regex = (nregcomp(fgstr, icase ? REG_ICASE :
+		0)) ? mallocstrcpy(NULL, fgstr) : NULL;
+
+	    /* Lame way to skip another static counter */
+            newcolor->id = endsyntax->nmultis;
+            endsyntax->nmultis++;
+	}
+    }
+}
+
+/* Parse the headers (1st line) of the file which may influence the regex used. */
+void parse_headers(char *ptr)
+{
+    char *regstr;
+
+    assert(ptr != NULL);
+
+    if (syntaxes == NULL) {
+	rcfile_error(
+		N_("Cannot add a header regex without a syntax command"));
+	return;
+    }
+
+    if (*ptr == '\0') {
+	rcfile_error(N_("Missing regex string"));
+	return;
+    }
+
+    /* Now for the fun part.  Start adding regexes to individual strings
+     * in the colorstrings array, woo! */
+    while (ptr != NULL && *ptr != '\0') {
+	exttype *newheader;
+	    /* The new color structure. */
+
+	if (*ptr != '"') {
+	    rcfile_error(
+		N_("Regex strings must begin and end with a \" character"));
+	    ptr = parse_next_regex(ptr);
+	    continue;
+	}
+
+	ptr++;
+
+	regstr = ptr;
+	ptr = parse_next_regex(ptr);
+	if (ptr == NULL)
+	    break;
+
+	newheader = (exttype *)nmalloc(sizeof(exttype));
+
+	/* Save the regex string if it's valid */
+	if (nregcomp(regstr, 0)) {
+	    newheader->ext_regex = mallocstrcpy(NULL, regstr);
+	    newheader->ext = NULL;
+	    newheader->next = NULL;
+
+#ifdef DEBUG
+	     fprintf(stderr, "Starting a new header entry: %s\n", newheader->ext_regex);
+#endif
+
+	    if (endheader == NULL) {
+		endsyntax->headers = newheader;
+	    } else {
+		endheader->next = newheader;
+	    }
+
+	    endheader = newheader;
+	} else
+	    free(newheader);
+
+    }
+}
+#endif /* ENABLE_COLOR */
+
+/* Check whether the user has unmapped every shortcut for a
+sequence we consider 'vital', like the exit function */
+static void check_vitals_mapped(void)
+{
+    subnfunc *f;
+    int v;
+#define VITALS 5
+    void (*vitals[VITALS])(void) = { do_exit, do_exit, do_cancel, do_cancel, do_cancel };
+    int inmenus[VITALS] = { MMAIN, MHELP, MWHEREIS, MREPLACE, MGOTOLINE };
+
+    for  (v = 0; v < VITALS; v++) {
+       for (f = allfuncs; f != NULL; f = f->next) {
+           if (f->scfunc == vitals[v] && f->menus & inmenus[v]) {
+               const sc *s = first_sc_for(inmenus[v], f->scfunc);
+               if (!s) {
+                   rcfile_error(N_("Fatal error: no keys mapped for function \"%s\""),
+                       f->desc);
+                   fprintf(stderr, N_("Exiting.  Please use nano with the -I option if needed to adjust your nanorc settings\n"));
+                   exit(1);
+               }
+           break;
+           }
+       }
+    }
+}
+
+/* Parse the rcfile, once it has been opened successfully at rcstream,
+ * and close it afterwards.  If syntax_only is TRUE, only allow the file
+ * to contain color syntax commands: syntax, color, and icolor. */
+void parse_rcfile(FILE *rcstream
+#ifdef ENABLE_COLOR
+	, bool syntax_only
+#endif
+	)
+{
+    char *buf = NULL;
+    ssize_t len;
+    size_t n = 0;
+
+    while ((len = getline(&buf, &n, rcstream)) > 0) {
+	char *ptr, *keyword, *option;
+	int set = 0;
+	size_t i;
+
+	/* Ignore the newline. */
+	if (buf[len - 1] == '\n')
+	    buf[len - 1] = '\0';
+
+	lineno++;
+	ptr = buf;
+	while (isblank(*ptr))
+	    ptr++;
+
+	/* If we have a blank line or a comment, skip to the next
+	 * line. */
+	if (*ptr == '\0' || *ptr == '#')
+	    continue;
+
+	/* Otherwise, skip to the next space. */
+	keyword = ptr;
+	ptr = parse_next_word(ptr);
+
+	/* Try to parse the keyword. */
+	if (strcasecmp(keyword, "set") == 0) {
+#ifdef ENABLE_COLOR
+	    if (syntax_only)
+		rcfile_error(
+			N_("Command \"%s\" not allowed in included file"),
+			keyword);
+	    else
+#endif
+		set = 1;
+	} else if (strcasecmp(keyword, "unset") == 0) {
+#ifdef ENABLE_COLOR
+	    if (syntax_only)
+		rcfile_error(
+			N_("Command \"%s\" not allowed in included file"),
+			keyword);
+	    else
+#endif
+		set = -1;
+	}
+#ifdef ENABLE_COLOR
+	else if (strcasecmp(keyword, "include") == 0) {
+	    if (syntax_only)
+		rcfile_error(
+			N_("Command \"%s\" not allowed in included file"),
+			keyword);
+	    else
+		parse_include(ptr);
+	} else if (strcasecmp(keyword, "syntax") == 0) {
+	    if (endsyntax != NULL && endcolor == NULL)
+		rcfile_error(N_("Syntax \"%s\" has no color commands"),
+			endsyntax->desc);
+	    parse_syntax(ptr);
+	}
+	else if (strcasecmp(keyword, "magic") == 0) {
+ 	    parse_magictype(ptr);
+	} else if (strcasecmp(keyword, "header") == 0)
+	    parse_headers(ptr);
+	else if (strcasecmp(keyword, "color") == 0)
+	    parse_colors(ptr, FALSE);
+	else if (strcasecmp(keyword, "icolor") == 0)
+	    parse_colors(ptr, TRUE);
+	else if (strcasecmp(keyword, "bind") == 0)
+	    parse_keybinding(ptr);
+	else if (strcasecmp(keyword, "unbind") == 0)
+	    parse_unbinding(ptr);
+#endif /* ENABLE_COLOR */
+	else
+	    rcfile_error(N_("Command \"%s\" not understood"), keyword);
+
+	if (set == 0)
+	    continue;
+
+	if (*ptr == '\0') {
+	    rcfile_error(N_("Missing flag"));
+	    continue;
+	}
+
+	option = ptr;
+	ptr = parse_next_word(ptr);
+
+	for (i = 0; rcopts[i].name != NULL; i++) {
+	    if (strcasecmp(option, rcopts[i].name) == 0) {
+#ifdef DEBUG
+		fprintf(stderr, "parse_rcfile(): name = \"%s\"\n", rcopts[i].name);
+#endif
+		if (set == 1) {
+		    if (rcopts[i].flag != 0)
+			/* This option has a flag, so it doesn't take an
+			 * argument. */
+			SET(rcopts[i].flag);
+		    else {
+			/* This option doesn't have a flag, so it takes
+			 * an argument. */
+			if (*ptr == '\0') {
+			    rcfile_error(
+				N_("Option \"%s\" requires an argument"),
+				rcopts[i].name);
+			    break;
+			}
+			option = ptr;
+			if (*option == '"')
+			    option++;
+			ptr = parse_argument(ptr);
+
+			option = mallocstrcpy(NULL, option);
+#ifdef DEBUG
+			fprintf(stderr, "option = \"%s\"\n", option);
+#endif
+
+			/* Make sure option is a valid multibyte
+			 * string. */
+			if (!is_valid_mbstring(option)) {
+			    rcfile_error(
+				N_("Option is not a valid multibyte string"));
+			    break;
+			}
+
+#ifndef DISABLE_OPERATINGDIR
+			if (strcasecmp(rcopts[i].name, "operatingdir") == 0)
+			    operating_dir = option;
+			else
+#endif
+#ifndef DISABLE_WRAPJUSTIFY
+			if (strcasecmp(rcopts[i].name, "fill") == 0) {
+			    if (!parse_num(option, &wrap_at)) {
+				rcfile_error(
+					N_("Requested fill size \"%s\" is invalid"),
+					option);
+				wrap_at = -CHARS_FROM_EOL;
+			    } else
+				free(option);
+			} else
+#endif
+#ifndef NANO_TINY
+			if (strcasecmp(rcopts[i].name,
+				"matchbrackets") == 0) {
+			    matchbrackets = option;
+			    if (has_blank_mbchars(matchbrackets)) {
+				rcfile_error(
+					N_("Non-blank characters required"));
+				free(matchbrackets);
+				matchbrackets = NULL;
+			    }
+			} else if (strcasecmp(rcopts[i].name,
+				"whitespace") == 0) {
+			    whitespace = option;
+			    if (mbstrlen(whitespace) != 2 ||
+				strlenpt(whitespace) != 2) {
+				rcfile_error(
+					N_("Two single-column characters required"));
+				free(whitespace);
+				whitespace = NULL;
+			    } else {
+				whitespace_len[0] =
+					parse_mbchar(whitespace, NULL,
+					NULL);
+				whitespace_len[1] =
+					parse_mbchar(whitespace +
+					whitespace_len[0], NULL, NULL);
+			    }
+			} else
+#endif
+#ifndef DISABLE_JUSTIFY
+			if (strcasecmp(rcopts[i].name, "punct") == 0) {
+			    punct = option;
+			    if (has_blank_mbchars(punct)) {
+				rcfile_error(
+					N_("Non-blank characters required"));
+				free(punct);
+				punct = NULL;
+			    }
+			} else if (strcasecmp(rcopts[i].name,
+				"brackets") == 0) {
+			    brackets = option;
+			    if (has_blank_mbchars(brackets)) {
+				rcfile_error(
+					N_("Non-blank characters required"));
+				free(brackets);
+				brackets = NULL;
+			    }
+			} else if (strcasecmp(rcopts[i].name,
+				"quotestr") == 0)
+			    quotestr = option;
+			else
+#endif
+#ifndef NANO_TINY
+			if (strcasecmp(rcopts[i].name,
+				"backupdir") == 0)
+			    backup_dir = option;
+			else
+#endif
+#ifndef DISABLE_SPELLER
+			if (strcasecmp(rcopts[i].name, "speller") == 0)
+			    alt_speller = option;
+			else
+#endif
+			if (strcasecmp(rcopts[i].name,
+				"tabsize") == 0) {
+			    if (!parse_num(option, &tabsize) ||
+				tabsize <= 0) {
+				rcfile_error(
+					N_("Requested tab size \"%s\" is invalid"),
+					option);
+				tabsize = -1;
+			    } else
+				free(option);
+			} else
+			    assert(FALSE);
+		    }
+#ifdef DEBUG
+		    fprintf(stderr, "flag = %ld\n", rcopts[i].flag);
+#endif
+		} else if (rcopts[i].flag != 0)
+		    UNSET(rcopts[i].flag);
+		else
+		    rcfile_error(N_("Cannot unset flag \"%s\""),
+			rcopts[i].name);
+		/* Looks like we still need this specific hack for undo */
+		if (strcasecmp(rcopts[i].name, "undo") == 0)
+		    shortcut_init(0);
+		break;
+	    }
+	}
+	if (rcopts[i].name == NULL)
+	    rcfile_error(N_("Unknown flag \"%s\""), option);
+    }
+
+#ifdef ENABLE_COLOR
+    if (endsyntax != NULL && endcolor == NULL)
+	rcfile_error(N_("Syntax \"%s\" has no color commands"),
+		endsyntax->desc);
+#endif
+
+    free(buf);
+    fclose(rcstream);
+    lineno = 0;
+
+    check_vitals_mapped();
+    return;
+}
+
+/* The main rcfile function.  It tries to open the system-wide rcfile,
+ * followed by the current user's rcfile. */
+void do_rcfile(void)
+{
+    struct stat rcinfo;
+    FILE *rcstream;
+
+    nanorc = mallocstrcpy(nanorc, SYSCONFDIR "/nanorc");
+
+    /* Don't open directories, character files, or block files. */
+    if (stat(nanorc, &rcinfo) != -1) {
+	if (S_ISDIR(rcinfo.st_mode) || S_ISCHR(rcinfo.st_mode) ||
+		S_ISBLK(rcinfo.st_mode))
+	    rcfile_error(S_ISDIR(rcinfo.st_mode) ?
+		_("\"%s\" is a directory") :
+		_("\"%s\" is a device file"), nanorc);
+    }
+
+#ifdef DEBUG
+    fprintf(stderr, "Parsing file \"%s\"\n", nanorc);
+#endif
+
+    /* Try to open the system-wide nanorc. */
+    rcstream = fopen(nanorc, "rb");
+    if (rcstream != NULL)
+	parse_rcfile(rcstream
+#ifdef ENABLE_COLOR
+		, FALSE
+#endif
+		);
+
+#ifdef DISABLE_ROOTWRAPPING
+    /* We've already read SYSCONFDIR/nanorc, if it's there.  If we're
+     * root, and --disable-wrapping-as-root is used, turn wrapping off
+     * now. */
+    if (geteuid() == NANO_ROOT_UID)
+	SET(NO_WRAP);
+#endif
+
+    get_homedir();
+
+    if (homedir == NULL)
+	rcfile_error(N_("I can't find my home directory!  Wah!"));
+    else {
+#ifndef RCFILE_NAME
+#define RCFILE_NAME ".nanorc"
+#endif
+	nanorc = charealloc(nanorc, strlen(homedir) + strlen(RCFILE_NAME) + 2);
+	sprintf(nanorc, "%s/%s", homedir, RCFILE_NAME);
+
+	/* Don't open directories, character files, or block files. */
+	if (stat(nanorc, &rcinfo) != -1) {
+	    if (S_ISDIR(rcinfo.st_mode) || S_ISCHR(rcinfo.st_mode) ||
+		S_ISBLK(rcinfo.st_mode))
+		rcfile_error(S_ISDIR(rcinfo.st_mode) ?
+			_("\"%s\" is a directory") :
+			_("\"%s\" is a device file"), nanorc);
+	}
+
+	/* Try to open the current user's nanorc. */
+	rcstream = fopen(nanorc, "rb");
+	if (rcstream == NULL) {
+	    /* Don't complain about the file's not existing. */
+	    if (errno != ENOENT)
+		rcfile_error(N_("Error reading %s: %s"), nanorc,
+			strerror(errno));
+	} else
+	    parse_rcfile(rcstream
+#ifdef ENABLE_COLOR
+		, FALSE
+#endif
+		);
+    }
+
+    free(nanorc);
+    nanorc = NULL;
+
+    if (errors && !ISSET(QUIET)) {
+	errors = FALSE;
+	fprintf(stderr,
+		_("\nPress Enter to continue starting nano.\n"));
+	while (getchar() != '\n')
+	    ;
+    }
+
+#ifdef ENABLE_COLOR
+    set_colorpairs();
+#endif
+}
+
+#endif /* ENABLE_NANORC */
diff --git a/src/search.c b/src/search.c
new file mode 100644
index 0000000..ca93098
--- /dev/null
+++ b/src/search.c
@@ -0,0 +1,1498 @@
+/* $Id: search.c 4527 2011-02-07 14:45:56Z astyanax $ */
+/**************************************************************************
+ *   search.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 <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <errno.h>
+#include <time.h>
+
+static bool search_last_line = FALSE;
+	/* Have we gone past the last line while searching? */
+#if !defined(NANO_TINY) && defined(ENABLE_NANORC)
+static bool history_changed = FALSE;
+	/* Have any of the history lists changed? */
+#endif
+#ifdef HAVE_REGEX_H
+static bool regexp_compiled = FALSE;
+	/* Have we compiled any regular expressions? */
+
+/* Compile the regular expression regexp to see if it's valid.  Return
+ * TRUE if it is, or FALSE otherwise. */
+bool regexp_init(const char *regexp)
+{
+    int rc;
+
+    assert(!regexp_compiled);
+
+    rc = regcomp(&search_regexp, regexp, REG_EXTENDED
+#ifndef NANO_TINY
+	| (ISSET(CASE_SENSITIVE) ? 0 : REG_ICASE)
+#endif
+	);
+
+    if (rc != 0) {
+	size_t len = regerror(rc, &search_regexp, NULL, 0);
+	char *str = charalloc(len);
+
+	regerror(rc, &search_regexp, str, len);
+	statusbar(_("Bad regex \"%s\": %s"), regexp, str);
+	free(str);
+
+	return FALSE;
+    }
+
+    regexp_compiled = TRUE;
+
+    return TRUE;
+}
+
+/* Decompile the compiled regular expression we used in the last
+ * search, if any. */
+void regexp_cleanup(void)
+{
+    if (regexp_compiled) {
+	regexp_compiled = FALSE;
+	regfree(&search_regexp);
+    }
+}
+#endif
+
+/* Indicate on the statusbar that the string at str was not found by the
+ * last search. */
+void not_found_msg(const char *str)
+{
+    char *disp;
+    int numchars;
+
+    assert(str != NULL);
+
+    disp = display_string(str, 0, (COLS / 2) + 1, FALSE);
+    numchars = actual_x(disp, mbstrnlen(disp, COLS / 2));
+
+    statusbar(_("\"%.*s%s\" not found"), numchars, disp,
+	(disp[numchars] == '\0') ? "" : "...");
+
+    free(disp);
+}
+
+/* Abort the current search or replace.  Clean up by displaying the main
+ * shortcut list, updating the screen if the mark was on before, and
+ * decompiling the compiled regular expression we used in the last
+ * search, if any. */
+void search_replace_abort(void)
+{
+    display_main_list();
+#ifndef NANO_TINY
+    if (openfile->mark_set)
+	edit_refresh();
+#endif
+#ifdef HAVE_REGEX_H
+    regexp_cleanup();
+#endif
+}
+
+/* Initialize the global search and replace strings. */
+void search_init_globals(void)
+{
+    if (last_search == NULL)
+	last_search = mallocstrcpy(NULL, "");
+    if (last_replace == NULL)
+	last_replace = mallocstrcpy(NULL, "");
+}
+
+/* Set up the system variables for a search or replace.  If use_answer
+ * is TRUE, only set backupstring to answer.  Return -2 to run the
+ * opposite program (search -> replace, replace -> search), return -1 if
+ * the search should be canceled (due to Cancel, a blank search string,
+ * Go to Line, or a failed regcomp()), return 0 on success, and return 1
+ * on rerun calling program.
+ *
+ * replacing is TRUE if we call from do_replace(), and FALSE if called
+ * from do_search(). */
+int search_init(bool replacing, bool use_answer)
+{
+    int i = 0;
+    char *buf;
+    sc *s;
+    void (*func)(void);
+    bool meta_key = FALSE, func_key = FALSE;
+    static char *backupstring = NULL;
+	/* The search string we'll be using. */
+
+    /* If backupstring doesn't exist, initialize it to "". */
+    if (backupstring == NULL)
+	backupstring = mallocstrcpy(NULL, "");
+
+    /* If use_answer is TRUE, set backupstring to answer and get out. */
+    if (use_answer) {
+	backupstring = mallocstrcpy(backupstring, answer);
+	return 0;
+    }
+
+    /* We display the search prompt below.  If the user types a partial
+     * search string and then Replace or a toggle, we will return to
+     * do_search() or do_replace() and be called again.  In that case,
+     * we should put the same search string back up. */
+
+    search_init_globals();
+
+    if (last_search[0] != '\0') {
+	char *disp = display_string(last_search, 0, COLS / 3, FALSE);
+
+	buf = charalloc(strlen(disp) + 7);
+	/* We use (COLS / 3) here because we need to see more on the
+	 * line. */
+	sprintf(buf, " [%s%s]", disp,
+		(strlenpt(last_search) > COLS / 3) ? "..." : "");
+	free(disp);
+    } else
+	buf = mallocstrcpy(NULL, "");
+
+    /* This is now one simple call.  It just does a lot. */
+    i = do_prompt(FALSE,
+#ifndef DISABLE_TABCOMP
+	TRUE,
+#endif
+	replacing ? MREPLACE : MWHEREIS, backupstring,
+	&meta_key, &func_key,
+#ifndef NANO_TINY
+	&search_history,
+#endif
+	edit_refresh, "%s%s%s%s%s%s", _("Search"),
+#ifndef NANO_TINY
+	/* TRANSLATORS: This string is just a modifier for the search
+	 * prompt; no grammar is implied. */
+	ISSET(CASE_SENSITIVE) ? _(" [Case Sensitive]") :
+#endif
+	"",
+#ifdef HAVE_REGEX_H
+	/* TRANSLATORS: This string is just a modifier for the search
+	 * prompt; no grammar is implied. */
+	ISSET(USE_REGEXP) ? _(" [Regexp]") :
+#endif
+	"",
+#ifndef NANO_TINY
+	/* TRANSLATORS: This string is just a modifier for the search
+	 * prompt; no grammar is implied. */
+	ISSET(BACKWARDS_SEARCH) ? _(" [Backwards]") :
+#endif
+	"", replacing ?
+#ifndef NANO_TINY
+	openfile->mark_set ? _(" (to replace) in selection") :
+#endif
+	_(" (to replace)") : "", buf);
+
+    fflush(stderr);
+
+    /* Release buf now that we don't need it anymore. */
+    free(buf);
+
+    free(backupstring);
+    backupstring = NULL;
+
+    /* Cancel any search, or just return with no previous search. */
+    if (i == -1 || (i < 0 && *last_search == '\0') || (!replacing &&
+	i == 0 && *answer == '\0')) {
+	statusbar(_("Cancelled"));
+	return -1;
+    } else {
+	for  (s = sclist; s != NULL; s = s->next)
+	    if ((s->menu & currmenu) && i == s->seq) {
+	        func = s->scfunc;
+	  	break;
+	    }
+
+	if (i == -2 || i == 0 ) {
+#ifdef HAVE_REGEX_H
+		/* Use last_search if answer is an empty string, or
+		 * answer if it isn't. */
+		if (ISSET(USE_REGEXP) && !regexp_init((i == -2) ?
+			last_search : answer))
+		    return -1;
+#endif
+		;
+#ifndef NANO_TINY
+	} else if (func == case_sens_void) {
+		TOGGLE(CASE_SENSITIVE);
+		backupstring = mallocstrcpy(backupstring, answer);
+		return 1;
+	} else if (func == backwards_void) {
+		TOGGLE(BACKWARDS_SEARCH);
+		backupstring = mallocstrcpy(backupstring, answer);
+		return 1;
+#endif
+#ifdef HAVE_REGEX_H
+	} else if (func == regexp_void) {
+		TOGGLE(USE_REGEXP);
+		backupstring = mallocstrcpy(backupstring, answer);
+		return 1;
+#endif
+	} else if (func == do_replace || func == no_replace_void) {
+		backupstring = mallocstrcpy(backupstring, answer);
+		return -2;	/* Call the opposite search function. */
+	} else if (func == do_gotolinecolumn_void) {
+		do_gotolinecolumn(openfile->current->lineno,
+			openfile->placewewant + 1, TRUE, TRUE, FALSE,
+			TRUE);
+				/* Put answer up on the statusbar and
+				 * fall through. */
+		return 3;
+	} else {
+		return -1;
+	}
+    }
+
+    return 0;
+}
+
+/* Look for needle, starting at (current, current_x).  If no_sameline is
+ * TRUE, skip over begin when looking for needle.  begin is the line
+ * where we first started searching, at column begin_x.  The return
+ * value specifies whether we found anything.  If we did, set needle_len
+ * to the length of the string we found if it isn't NULL. */
+bool findnextstr(
+#ifndef DISABLE_SPELLER
+	bool whole_word,
+#endif
+	bool no_sameline, const filestruct *begin, size_t begin_x, const
+	char *needle, size_t *needle_len)
+{
+    size_t found_len;
+	/* The length of the match we find. */
+    size_t current_x_find = 0;
+	/* The location in the current line of the match we find. */
+    ssize_t current_y_find = openfile->current_y;
+    filestruct *fileptr = openfile->current;
+    const char *rev_start = fileptr->data, *found = NULL;
+    const subnfunc *f;
+    time_t lastkbcheck = time(NULL);
+
+    /* rev_start might end up 1 character before the start or after the
+     * end of the line.  This won't be a problem because strstrwrapper()
+     * will return immediately and say that no match was found, and
+     * rev_start will be properly set when the search continues on the
+     * previous or next line. */
+    rev_start +=
+#ifndef NANO_TINY
+	ISSET(BACKWARDS_SEARCH) ?
+	openfile->current_x - 1 :
+#endif
+	openfile->current_x + 1;
+
+    /* Look for needle in the current line we're searching. */
+    enable_nodelay();
+    while (TRUE) {
+        if (time(NULL) - lastkbcheck > 1) {
+            lastkbcheck = time(NULL);
+	    f = getfuncfromkey(edit);
+            if (f && f->scfunc == do_cancel) {
+		statusbar(_("Cancelled"));
+		return FALSE;
+	    }
+	}
+
+	found = strstrwrapper(fileptr->data, needle, rev_start);
+
+	/* We've found a potential match. */
+	if (found != NULL) {
+#ifndef DISABLE_SPELLER
+	    bool found_whole = FALSE;
+		/* Is this potential match a whole word? */
+#endif
+
+	    /* Set found_len to the length of the potential match. */
+	    found_len =
+#ifdef HAVE_REGEX_H
+		ISSET(USE_REGEXP) ?
+		regmatches[0].rm_eo - regmatches[0].rm_so :
+#endif
+		strlen(needle);
+
+#ifndef DISABLE_SPELLER
+	    /* If we're searching for whole words, see if this potential
+	     * match is a whole word. */
+	    if (whole_word) {
+		char *word = mallocstrncpy(NULL, found, found_len + 1);
+		word[found_len] = '\0';
+
+		found_whole = is_whole_word(found - fileptr->data,
+			fileptr->data, word);
+		free(word);
+	    }
+#endif
+
+	    /* If we're searching for whole words and this potential
+	     * match isn't a whole word, or if we're not allowed to find
+	     * a match on the same line we started on and this potential
+	     * match is on that line, continue searching. */
+	    if (
+#ifndef DISABLE_SPELLER
+		(!whole_word || found_whole) &&
+#endif
+		(!no_sameline || fileptr != openfile->current))
+		break;
+	}
+
+	/* We've finished processing the file, so get out. */
+	if (search_last_line) {
+	    not_found_msg(needle);
+            disable_nodelay();
+	    return FALSE;
+	}
+
+	/* Move to the previous or next line in the file. */
+#ifndef NANO_TINY
+	if (ISSET(BACKWARDS_SEARCH)) {
+	    fileptr = fileptr->prev;
+	    current_y_find--;
+	} else {
+#endif
+	    fileptr = fileptr->next;
+	    current_y_find++;
+#ifndef NANO_TINY
+	}
+#endif
+
+	/* We've reached the start or end of the buffer, so wrap
+	 * around. */
+	if (fileptr == NULL) {
+#ifndef NANO_TINY
+	    if (ISSET(BACKWARDS_SEARCH)) {
+		fileptr = openfile->filebot;
+		current_y_find = editwinrows - 1;
+	    } else {
+#endif
+		fileptr = openfile->fileage;
+		current_y_find = 0;
+#ifndef NANO_TINY
+	    }
+#endif
+	    statusbar(_("Search Wrapped"));
+	}
+
+	/* We've reached the original starting line. */
+	if (fileptr == begin)
+	    search_last_line = TRUE;
+
+	rev_start = fileptr->data;
+#ifndef NANO_TINY
+	if (ISSET(BACKWARDS_SEARCH))
+	    rev_start += strlen(fileptr->data);
+#endif
+    }
+
+    /* We found an instance. */
+    current_x_find = found - fileptr->data;
+
+    /* Ensure we haven't wrapped around again! */
+    if (search_last_line &&
+#ifndef NANO_TINY
+	((!ISSET(BACKWARDS_SEARCH) && current_x_find > begin_x) ||
+	(ISSET(BACKWARDS_SEARCH) && current_x_find < begin_x))
+#else
+	current_x_find > begin_x
+#endif
+	) {
+	not_found_msg(needle);
+	disable_nodelay();
+	return FALSE;
+    }
+
+    disable_nodelay();
+    /* We've definitely found something. */
+    openfile->current = fileptr;
+    openfile->current_x = current_x_find;
+    openfile->placewewant = xplustabs();
+    openfile->current_y = current_y_find;
+
+    /* needle_len holds the length of needle. */
+    if (needle_len != NULL)
+	*needle_len = found_len;
+
+    return TRUE;
+}
+
+/* Clear the flag indicating that a search reached the last line of the
+ * file.  We need to do this just before a new search. */
+void findnextstr_wrap_reset(void)
+{
+    search_last_line = FALSE;
+}
+
+/* Search for a string. */
+void do_search(void)
+{
+    filestruct *fileptr = openfile->current;
+    size_t fileptr_x = openfile->current_x;
+    size_t pww_save = openfile->placewewant;
+    int i;
+    bool didfind;
+
+    i = search_init(FALSE, FALSE);
+
+    if (i == -1)
+	/* Cancel, Go to Line, blank search string, or regcomp()
+	 * failed. */
+	search_replace_abort();
+    else if (i == -2)
+	/* Replace. */
+	do_replace();
+#if !defined(NANO_TINY) || defined(HAVE_REGEX_H)
+    else if (i == 1)
+	/* Case Sensitive, Backwards, or Regexp search toggle. */
+	do_search();
+#endif
+
+    if (i != 0)
+	return;
+
+    /* If answer is now "", copy last_search into answer. */
+    if (*answer == '\0')
+	answer = mallocstrcpy(answer, last_search);
+    else
+	last_search = mallocstrcpy(last_search, answer);
+
+#ifndef NANO_TINY
+    /* If answer is not "", add this search string to the search history
+     * list. */
+    if (answer[0] != '\0')
+	update_history(&search_history, answer);
+#endif
+
+    findnextstr_wrap_reset();
+    didfind = findnextstr(
+#ifndef DISABLE_SPELLER
+	FALSE,
+#endif
+	FALSE, openfile->current, openfile->current_x, answer, NULL);
+
+    /* Check to see if there's only one occurrence of the string and
+     * we're on it now. */
+    if (fileptr == openfile->current && fileptr_x ==
+	openfile->current_x && didfind) {
+#ifdef HAVE_REGEX_H
+	/* Do the search again, skipping over the current line, if we're
+	 * doing a bol and/or eol regex search ("^", "$", or "^$"), so
+	 * that we find one only once per line.  We should only end up
+	 * back at the same position if the string isn't found again, in
+	 * which case it's the only occurrence. */
+	if (ISSET(USE_REGEXP) && regexp_bol_or_eol(&search_regexp,
+		last_search)) {
+	    didfind = findnextstr(
+#ifndef DISABLE_SPELLER
+		FALSE,
+#endif
+		TRUE, openfile->current,
+		openfile->current_x, answer, NULL);
+	    if (fileptr == openfile->current && fileptr_x ==
+		openfile->current_x && !didfind)
+		statusbar(_("This is the only occurrence"));
+	} else {
+#endif
+	    statusbar(_("This is the only occurrence"));
+#ifdef HAVE_REGEX_H
+	}
+#endif
+    }
+
+    openfile->placewewant = xplustabs();
+    edit_redraw(fileptr, pww_save);
+    search_replace_abort();
+}
+
+#ifndef NANO_TINY
+/* Search for the last string without prompting. */
+void do_research(void)
+{
+    filestruct *fileptr = openfile->current;
+    size_t fileptr_x = openfile->current_x;
+    size_t pww_save = openfile->placewewant;
+    bool didfind;
+
+    search_init_globals();
+
+    if (last_search[0] != '\0') {
+#ifdef HAVE_REGEX_H
+	/* Since answer is "", use last_search! */
+	if (ISSET(USE_REGEXP) && !regexp_init(last_search))
+	    return;
+#endif
+
+	findnextstr_wrap_reset();
+	didfind = findnextstr(
+#ifndef DISABLE_SPELLER
+		FALSE,
+#endif
+		FALSE, openfile->current, openfile->current_x,
+		last_search, NULL);
+
+	/* Check to see if there's only one occurrence of the string and
+	 * we're on it now. */
+	if (fileptr == openfile->current && fileptr_x ==
+		openfile->current_x && didfind) {
+#ifdef HAVE_REGEX_H
+	    /* Do the search again, skipping over the current line, if
+	     * we're doing a bol and/or eol regex search ("^", "$", or
+	     * "^$"), so that we find one only once per line.  We should
+	     * only end up back at the same position if the string isn't
+	     * found again, in which case it's the only occurrence. */
+	    if (ISSET(USE_REGEXP) && regexp_bol_or_eol(&search_regexp,
+		last_search)) {
+		didfind = findnextstr(
+#ifndef DISABLE_SPELLER
+			FALSE,
+#endif
+			TRUE, openfile->current, openfile->current_x,
+			answer, NULL);
+		if (fileptr == openfile->current && fileptr_x ==
+			openfile->current_x && !didfind)
+		    statusbar(_("This is the only occurrence"));
+	    } else {
+#endif
+		statusbar(_("This is the only occurrence"));
+#ifdef HAVE_REGEX_H
+	    }
+#endif
+	}
+    } else
+        statusbar(_("No current search pattern"));
+
+    openfile->placewewant = xplustabs();
+    edit_redraw(fileptr, pww_save);
+    search_replace_abort();
+}
+#endif
+
+#ifdef HAVE_REGEX_H
+int replace_regexp(char *string, bool create)
+{
+    /* We have a split personality here.  If create is FALSE, just
+     * calculate the size of the replacement line (necessary because of
+     * subexpressions \1 to \9 in the replaced text). */
+
+    const char *c = last_replace;
+    size_t search_match_count = regmatches[0].rm_eo -
+	regmatches[0].rm_so;
+    size_t new_line_size = strlen(openfile->current->data) + 1 -
+	search_match_count;
+
+    /* Iterate through the replacement text to handle subexpression
+     * replacement using \1, \2, \3, etc. */
+    while (*c != '\0') {
+	int num = (*(c + 1) - '0');
+
+	if (*c != '\\' || num < 1 || num > 9 || num >
+		search_regexp.re_nsub) {
+	    if (create)
+		*string++ = *c;
+	    c++;
+	    new_line_size++;
+	} else {
+	    size_t i = regmatches[num].rm_eo - regmatches[num].rm_so;
+
+	    /* Skip over the replacement expression. */
+	    c += 2;
+
+	    /* But add the length of the subexpression to new_size. */
+	    new_line_size += i;
+
+	    /* And if create is TRUE, append the result of the
+	     * subexpression match to the new line. */
+	    if (create) {
+		strncpy(string, openfile->current->data +
+			openfile->current_x + regmatches[num].rm_so, i);
+		string += i;
+	    }
+	}
+    }
+
+    if (create)
+	*string = '\0';
+
+    return new_line_size;
+}
+#endif
+
+char *replace_line(const char *needle)
+{
+    char *copy;
+    size_t new_line_size, search_match_count;
+
+    /* Calculate the size of the new line. */
+#ifdef HAVE_REGEX_H
+    if (ISSET(USE_REGEXP)) {
+	search_match_count = regmatches[0].rm_eo - regmatches[0].rm_so;
+	new_line_size = replace_regexp(NULL, FALSE);
+    } else {
+#endif
+	search_match_count = strlen(needle);
+	new_line_size = strlen(openfile->current->data) -
+		search_match_count + strlen(answer) + 1;
+#ifdef HAVE_REGEX_H
+    }
+#endif
+
+    /* Create the buffer. */
+    copy = charalloc(new_line_size);
+
+    /* The head of the original line. */
+    strncpy(copy, openfile->current->data, openfile->current_x);
+
+    /* The replacement text. */
+#ifdef HAVE_REGEX_H
+    if (ISSET(USE_REGEXP))
+	replace_regexp(copy + openfile->current_x, TRUE);
+    else
+#endif
+	strcpy(copy + openfile->current_x, answer);
+
+    /* The tail of the original line. */
+    assert(openfile->current_x + search_match_count <= strlen(openfile->current->data));
+
+    strcat(copy, openfile->current->data + openfile->current_x +
+	search_match_count);
+
+    return copy;
+}
+
+/* Step through each replace word and prompt user before replacing.
+ * Parameters real_current and real_current_x are needed in order to
+ * allow the cursor position to be updated when a word before the cursor
+ * is replaced by a shorter word.
+ *
+ * needle is the string to seek.  We replace it with answer.  Return -1
+ * if needle isn't found, else the number of replacements performed.  If
+ * canceled isn't NULL, set it to TRUE if we canceled. */
+ssize_t do_replace_loop(
+#ifndef DISABLE_SPELLER
+	bool whole_word,
+#endif
+	bool *canceled, const filestruct *real_current, size_t
+	*real_current_x, const char *needle)
+{
+    ssize_t numreplaced = -1;
+    size_t match_len;
+    bool replaceall = FALSE;
+#ifdef HAVE_REGEX_H
+    /* The starting-line match and bol/eol regex flags. */
+    bool begin_line = FALSE, bol_or_eol = FALSE;
+#endif
+#ifndef NANO_TINY
+    bool old_mark_set = openfile->mark_set;
+    filestruct *edittop_save = openfile->edittop, *top, *bot;
+    size_t top_x, bot_x;
+    bool right_side_up = FALSE;
+	/* TRUE if (mark_begin, mark_begin_x) is the top of the mark,
+	 * FALSE if (current, current_x) is. */
+
+    if (old_mark_set) {
+	/* If the mark is on, partition the filestruct so that it
+	 * contains only the marked text, set edittop to the top of the
+	 * partition, turn the mark off, and refresh the screen. */
+	mark_order((const filestruct **)&top, &top_x,
+	    (const filestruct **)&bot, &bot_x, &right_side_up);
+	filepart = partition_filestruct(top, top_x, bot, bot_x);
+	openfile->edittop = openfile->fileage;
+	openfile->mark_set = FALSE;
+#ifdef ENABLE_COLOR
+	reset_multis(openfile->current, TRUE);
+#endif
+	edit_refresh();
+    }
+#endif
+
+    if (canceled != NULL)
+	*canceled = FALSE;
+
+    findnextstr_wrap_reset();
+    while (findnextstr(
+#ifndef DISABLE_SPELLER
+	whole_word,
+#endif
+#ifdef HAVE_REGEX_H
+	/* We should find a bol and/or eol regex only once per line.  If
+	 * the bol_or_eol flag is set, it means that the last search
+	 * found one on the beginning line, so we should skip over the
+	 * beginning line when doing this search. */
+	bol_or_eol
+#else
+	FALSE
+#endif
+	, real_current, *real_current_x, needle, &match_len)) {
+	int i = 0;
+
+#ifdef HAVE_REGEX_H
+	/* If the bol_or_eol flag is set, we've found a match on the
+	 * beginning line already, and we're still on the beginning line
+	 * after the search, it means that we've wrapped around, so
+	 * we're done. */
+	if (bol_or_eol && begin_line && openfile->current ==
+		real_current)
+	    break;
+	/* Otherwise, set the begin_line flag if we've found a match on
+	 * the beginning line, reset the bol_or_eol flag, and
+	 * continue. */
+	else {
+	    if (openfile->current == real_current)
+		begin_line = TRUE;
+	    bol_or_eol = FALSE;
+	}
+#endif
+
+	if (!replaceall)
+	    edit_refresh();
+
+	/* Indicate that we found the search string. */
+	if (numreplaced == -1)
+	    numreplaced = 0;
+
+	if (!replaceall) {
+	    size_t xpt = xplustabs();
+	    char *exp_word = display_string(openfile->current->data,
+		xpt, strnlenpt(openfile->current->data,
+		openfile->current_x + match_len) - xpt, FALSE);
+
+	    curs_set(0);
+
+	    do_replace_highlight(TRUE, exp_word);
+
+	    i = do_yesno_prompt(TRUE, _("Replace this instance?"));
+
+	    do_replace_highlight(FALSE, exp_word);
+
+	    free(exp_word);
+
+	    curs_set(1);
+
+	    if (i == -1) {	/* We canceled the replace. */
+		if (canceled != NULL)
+		    *canceled = TRUE;
+		break;
+	    }
+	}
+
+#ifdef HAVE_REGEX_H
+	/* Set the bol_or_eol flag if we're doing a bol and/or eol regex
+	 * replace ("^", "$", or "^$"). */
+	if (ISSET(USE_REGEXP) && regexp_bol_or_eol(&search_regexp,
+		needle))
+	    bol_or_eol = TRUE;
+#endif
+
+	if (i > 0 || replaceall) {	/* Yes, replace it!!!! */
+	    char *copy;
+	    size_t length_change;
+
+#ifndef NANO_TINY
+	    update_undo(REPLACE);
+#endif
+	    if (i == 2)
+		replaceall = TRUE;
+
+	    copy = replace_line(needle);
+
+	    length_change = strlen(copy) -
+		strlen(openfile->current->data);
+
+#ifndef NANO_TINY
+	    /* If the mark was on and (mark_begin, mark_begin_x) was the
+	     * top of it, don't change mark_begin_x. */
+	    if (!old_mark_set || !right_side_up) {
+		/* Keep mark_begin_x in sync with the text changes. */
+		if (openfile->current == openfile->mark_begin &&
+			openfile->mark_begin_x > openfile->current_x) {
+		    if (openfile->mark_begin_x < openfile->current_x +
+			match_len)
+			openfile->mark_begin_x = openfile->current_x;
+		    else
+			openfile->mark_begin_x += length_change;
+		}
+	    }
+
+	    /* If the mark was on and (current, current_x) was the top
+	     * of it, don't change real_current_x. */
+	    if (!old_mark_set || right_side_up) {
+#endif
+		/* Keep real_current_x in sync with the text changes. */
+		if (openfile->current == real_current &&
+			openfile->current_x <= *real_current_x) {
+		    if (*real_current_x <
+			openfile->current_x + match_len)
+			*real_current_x = openfile->current_x +
+				match_len;
+		    *real_current_x += length_change;
+		}
+#ifndef NANO_TINY
+	    }
+#endif
+
+	    /* Set the cursor at the last character of the replacement
+	     * text, so searching will resume after the replacement
+	     * text.  Note that current_x might be set to (size_t)-1
+	     * here. */
+#ifndef NANO_TINY
+	    if (!ISSET(BACKWARDS_SEARCH))
+#endif
+		openfile->current_x += match_len + length_change - 1;
+
+	    /* Cleanup. */
+	    openfile->totsize += mbstrlen(copy) -
+		mbstrlen(openfile->current->data);
+	    free(openfile->current->data);
+	    openfile->current->data = copy;
+
+#ifdef ENABLE_COLOR
+	reset_multis(openfile->current, TRUE);
+#endif
+	edit_refresh();
+	    if (!replaceall) {
+#ifdef ENABLE_COLOR
+		/* If color syntaxes are available and turned on, we
+		 * need to call edit_refresh(). */
+		if (openfile->colorstrings != NULL &&
+			!ISSET(NO_COLOR_SYNTAX))
+		    edit_refresh();
+		else
+#endif
+		    update_line(openfile->current, openfile->current_x);
+	    }
+
+	    set_modified();
+	    numreplaced++;
+	}
+    }
+
+#ifndef NANO_TINY
+    if (old_mark_set) {
+	/* If the mark was on, unpartition the filestruct so that it
+	 * contains all the text again, set edittop back to what it was
+	 * before, turn the mark back on, and refresh the screen. */
+	unpartition_filestruct(&filepart);
+	openfile->edittop = edittop_save;
+	openfile->mark_set = TRUE;
+	edit_refresh();
+    }
+#endif
+
+    /* 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();
+
+    return numreplaced;
+}
+
+/* Replace a string. */
+void do_replace(void)
+{
+    filestruct *edittop_save, *begin;
+    size_t begin_x, pww_save;
+    bool meta_key = FALSE, func_key = FALSE;
+    ssize_t numreplaced;
+    int i;
+
+    if (ISSET(VIEW_MODE)) {
+	print_view_warning();
+	search_replace_abort();
+	return;
+    }
+
+    i = search_init(TRUE, FALSE);
+    if (i == -1) {
+	/* Cancel, Go to Line, blank search string, or regcomp()
+	 * failed. */
+	search_replace_abort();
+	return;
+    } else if (i == -2) {
+	/* No Replace. */
+	do_search();
+	return;
+    } else if (i == 1)
+	/* Case Sensitive, Backwards, or Regexp search toggle. */
+	do_replace();
+
+    if (i != 0)
+	return;
+
+    /* If answer is not "", add answer to the search history list and
+     * copy answer into last_search. */
+    if (answer[0] != '\0') {
+#ifndef NANO_TINY
+	update_history(&search_history, answer);
+#endif
+	last_search = mallocstrcpy(last_search, answer);
+    }
+
+    last_replace = mallocstrcpy(last_replace, "");
+
+    i = do_prompt(FALSE,
+#ifndef DISABLE_TABCOMP
+	TRUE,
+#endif
+	MREPLACE2, last_replace,
+	&meta_key, &func_key,
+#ifndef NANO_TINY
+	&replace_history,
+#endif
+	edit_refresh, _("Replace with"));
+
+#ifndef NANO_TINY
+    /* Add this replace string to the replace history list.  i == 0
+     * means that the string is not "". */
+    if (i == 0)
+	update_history(&replace_history, answer);
+#endif
+
+    if (i != 0 && i != -2) {
+	if (i == -1) {		/* Cancel. */
+	    if (last_replace[0] != '\0')
+		answer = mallocstrcpy(answer, last_replace);
+	    statusbar(_("Cancelled"));
+	}
+	search_replace_abort();
+	return;
+    }
+
+    last_replace = mallocstrcpy(last_replace, answer);
+
+    /* Save where we are. */
+    edittop_save = openfile->edittop;
+    begin = openfile->current;
+    begin_x = openfile->current_x;
+    pww_save = openfile->placewewant;
+
+    numreplaced = do_replace_loop(
+#ifndef DISABLE_SPELLER
+	FALSE,
+#endif
+	NULL, begin, &begin_x, last_search);
+
+    /* Restore where we were. */
+    openfile->edittop = edittop_save;
+    openfile->current = begin;
+    openfile->current_x = begin_x;
+    openfile->placewewant = pww_save;
+
+    edit_refresh();
+
+    if (numreplaced >= 0)
+	statusbar(P_("Replaced %lu occurrence",
+		"Replaced %lu occurrences", (unsigned long)numreplaced),
+		(unsigned long)numreplaced);
+
+    search_replace_abort();
+}
+
+/* Go to the specified line and column, or ask for them if interactive
+ * is TRUE.  Save the x-coordinate and y-coordinate if save_pos is TRUE.
+ * Update the screen afterwards if allow_update is TRUE.  Note that both
+ * the line and column numbers should be one-based. */
+void do_gotolinecolumn(ssize_t line, ssize_t column, bool use_answer,
+	bool interactive, bool save_pos, bool allow_update)
+{
+    bool meta_key = FALSE, func_key = FALSE;
+    const sc *s;
+
+    if (interactive) {
+	char *ans = mallocstrcpy(NULL, answer);
+
+	/* Ask for the line and column. */
+	int i = do_prompt(FALSE,
+#ifndef DISABLE_TABCOMP
+		TRUE,
+#endif
+		MGOTOLINE, use_answer ? ans : "",
+		&meta_key, &func_key,
+#ifndef NANO_TINY
+		NULL,
+#endif
+		edit_refresh, _("Enter line number, column number"));
+
+	free(ans);
+
+	/* Cancel, or Enter with blank string. */
+	if (i < 0) {
+	    statusbar(_("Cancelled"));
+	    display_main_list();
+	    return;
+	}
+
+
+	s = get_shortcut(currmenu, &i, &meta_key, &func_key);
+	if (s && s->scfunc ==  gototext_void) {
+	    /* Keep answer up on the statusbar. */
+	    search_init(TRUE, TRUE);
+
+	    do_search();
+	    return;
+	}
+
+	/* Do a bounds check.  Display a warning on an out-of-bounds
+	 * line or column number only if we hit Enter at the statusbar
+	 * prompt. */
+	if (!parse_line_column(answer, &line, &column) || line < 1 ||
+		column < 1) {
+	    if (i == 0)
+		statusbar(_("Invalid line or column number"));
+	    display_main_list();
+	    return;
+	}
+    } else {
+	if (line < 1)
+	    line = openfile->current->lineno;
+
+	if (column < 1)
+	    column = openfile->placewewant + 1;
+    }
+
+    for (openfile->current = openfile->fileage;
+	openfile->current != openfile->filebot && line > 1; line--)
+	openfile->current = openfile->current->next;
+
+    openfile->current_x = actual_x(openfile->current->data, column - 1);
+    openfile->placewewant = column - 1;
+
+    /* Put the top line of the edit window in range of the current line.
+     * If save_pos is TRUE, don't change the cursor position when doing
+     * it. */
+    edit_update(save_pos ? NONE : CENTER);
+
+    /* If allow_update is TRUE, update the screen. */
+    if (allow_update)
+	edit_refresh();
+
+    display_main_list();
+}
+
+/* Go to the specified line and column, asking for them beforehand. */
+void do_gotolinecolumn_void(void)
+{
+    do_gotolinecolumn(openfile->current->lineno,
+	openfile->placewewant + 1, FALSE, TRUE, FALSE, TRUE);
+}
+
+#ifndef DISABLE_SPELLER
+/* Go to the line with the number specified in pos_line, the
+ * x-coordinate specified in pos_x, the y-coordinate specified in pos_y,
+ * and the place we want specified in pos_pww. */
+void do_gotopos(ssize_t pos_line, size_t pos_x, ssize_t pos_y, size_t
+	pos_pww)
+{
+    /* Since do_gotolinecolumn() resets the x-coordinate but not the
+     * y-coordinate, set the coordinates up this way. */
+    openfile->current_y = pos_y;
+    do_gotolinecolumn(pos_line, pos_x + 1, FALSE, FALSE, TRUE, TRUE);
+
+    /* Set the rest of the coordinates up. */
+    openfile->placewewant = pos_pww;
+    update_line(openfile->current, pos_x);
+}
+#endif
+
+#ifndef NANO_TINY
+/* Search for a match to one of the two characters in bracket_set.  If
+ * reverse is TRUE, search backwards for the leftmost bracket.
+ * Otherwise, search forwards for the rightmost bracket.  Return TRUE if
+ * we found a match, and FALSE otherwise. */
+bool find_bracket_match(bool reverse, const char *bracket_set)
+{
+    filestruct *fileptr = openfile->current;
+    const char *rev_start = NULL, *found = NULL;
+    ssize_t current_y_find = openfile->current_y;
+
+    assert(mbstrlen(bracket_set) == 2);
+
+    /* rev_start might end up 1 character before the start or after the
+     * end of the line.  This won't be a problem because we'll skip over
+     * it below in that case, and rev_start will be properly set when
+     * the search continues on the previous or next line. */
+    rev_start = reverse ? fileptr->data + (openfile->current_x - 1) :
+	fileptr->data + (openfile->current_x + 1);
+
+    /* Look for either of the two characters in bracket_set.  rev_start
+     * can be 1 character before the start or after the end of the line.
+     * In either case, just act as though no match is found. */
+    while (TRUE) {
+	found = ((rev_start > fileptr->data && *(rev_start - 1) ==
+		'\0') || rev_start < fileptr->data) ? NULL : (reverse ?
+		mbrevstrpbrk(fileptr->data, bracket_set, rev_start) :
+		mbstrpbrk(rev_start, bracket_set));
+
+	/* We've found a potential match. */
+	if (found != NULL)
+	    break;
+
+	if (reverse) {
+	    fileptr = fileptr->prev;
+	    current_y_find--;
+	} else {
+	    fileptr = fileptr->next;
+	    current_y_find++;
+	}
+
+	/* We've reached the start or end of the buffer, so get out. */
+	if (fileptr == NULL)
+	    return FALSE;
+
+	rev_start = fileptr->data;
+	if (reverse)
+	    rev_start += strlen(fileptr->data);
+    }
+
+    /* We've definitely found something. */
+    openfile->current = fileptr;
+    openfile->current_x = found - fileptr->data;
+    openfile->placewewant = xplustabs();
+    openfile->current_y = current_y_find;
+
+    return TRUE;
+}
+
+/* Search for a match to the bracket at the current cursor position, if
+ * there is one. */
+void do_find_bracket(void)
+{
+    filestruct *current_save;
+    size_t current_x_save, pww_save;
+    const char *ch;
+	/* The location in matchbrackets of the bracket at the current
+	 * cursor position. */
+    int ch_len;
+	/* The length of ch in bytes. */
+    const char *wanted_ch;
+	/* The location in matchbrackets of the bracket complementing
+	 * the bracket at the current cursor position. */
+    int wanted_ch_len;
+	/* The length of wanted_ch in bytes. */
+    char *bracket_set;
+	/* The pair of characters in ch and wanted_ch. */
+    size_t i;
+	/* Generic loop variable. */
+    size_t matchhalf;
+	/* The number of single-byte characters in one half of
+	 * matchbrackets. */
+    size_t mbmatchhalf;
+	/* The number of multibyte characters in one half of
+	 * matchbrackets. */
+    size_t count = 1;
+	/* The initial bracket count. */
+    bool reverse;
+	/* The direction we search. */
+    char *found_ch;
+	/* The character we find. */
+
+    assert(mbstrlen(matchbrackets) % 2 == 0);
+
+    ch = openfile->current->data + openfile->current_x;
+
+    if (ch == '\0' || (ch = mbstrchr(matchbrackets, ch)) == NULL) {
+	statusbar(_("Not a bracket"));
+	return;
+    }
+
+    /* Save where we are. */
+    current_save = openfile->current;
+    current_x_save = openfile->current_x;
+    pww_save = openfile->placewewant;
+
+    /* If we're on an opening bracket, which must be in the first half
+     * of matchbrackets, we want to search forwards for a closing
+     * bracket.  If we're on a closing bracket, which must be in the
+     * second half of matchbrackets, we want to search backwards for an
+     * opening bracket. */
+    matchhalf = 0;
+    mbmatchhalf = mbstrlen(matchbrackets) / 2;
+
+    for (i = 0; i < mbmatchhalf; i++)
+	matchhalf += parse_mbchar(matchbrackets + matchhalf, NULL,
+		NULL);
+
+    reverse = ((ch - matchbrackets) >= matchhalf);
+
+    /* If we're on an opening bracket, set wanted_ch to the character
+     * that's matchhalf characters after ch.  If we're on a closing
+     * bracket, set wanted_ch to the character that's matchhalf
+     * characters before ch. */
+    wanted_ch = ch;
+
+    while (mbmatchhalf > 0) {
+	if (reverse)
+	    wanted_ch = matchbrackets + move_mbleft(matchbrackets,
+		wanted_ch - matchbrackets);
+	else
+	    wanted_ch += move_mbright(wanted_ch, 0);
+
+	mbmatchhalf--;
+    }
+
+    ch_len = parse_mbchar(ch, NULL, NULL);
+    wanted_ch_len = parse_mbchar(wanted_ch, NULL, NULL);
+
+    /* Fill bracket_set in with the values of ch and wanted_ch. */
+    bracket_set = charalloc((mb_cur_max() * 2) + 1);
+    strncpy(bracket_set, ch, ch_len);
+    strncpy(bracket_set + ch_len, wanted_ch, wanted_ch_len);
+    null_at(&bracket_set, ch_len + wanted_ch_len);
+
+    found_ch = charalloc(mb_cur_max() + 1);
+
+    while (TRUE) {
+	if (find_bracket_match(reverse, bracket_set)) {
+	    /* If we found an identical bracket, increment count.  If we
+	     * found a complementary bracket, decrement it. */
+	    parse_mbchar(openfile->current->data + openfile->current_x,
+		found_ch, NULL);
+	    count += (strncmp(found_ch, ch, ch_len) == 0) ? 1 : -1;
+
+	    /* If count is zero, we've found a matching bracket.  Update
+	     * the screen and get out. */
+	    if (count == 0) {
+		edit_redraw(current_save, pww_save);
+		break;
+	    }
+	} else {
+	    /* We didn't find either an opening or closing bracket.
+	     * Indicate this, restore where we were, and get out. */
+	    statusbar(_("No matching bracket"));
+	    openfile->current = current_save;
+	    openfile->current_x = current_x_save;
+	    openfile->placewewant = pww_save;
+	    break;
+	}
+    }
+
+    /* Clean up. */
+    free(bracket_set);
+    free(found_ch);
+}
+
+#ifdef ENABLE_NANORC
+/* Indicate whether any of the history lists have changed. */
+bool history_has_changed(void)
+{
+    return history_changed;
+}
+#endif
+
+/* Initialize the search and replace history lists. */
+void history_init(void)
+{
+    search_history = make_new_node(NULL);
+    search_history->data = mallocstrcpy(NULL, "");
+    searchage = search_history;
+    searchbot = search_history;
+
+    replace_history = make_new_node(NULL);
+    replace_history->data = mallocstrcpy(NULL, "");
+    replaceage = replace_history;
+    replacebot = replace_history;
+}
+
+/* Set the current position in the history list h to the bottom. */
+void history_reset(const filestruct *h)
+{
+    if (h == search_history)
+	search_history = searchbot;
+    else if (h == replace_history)
+	replace_history = replacebot;
+}
+
+/* Return the first node containing the first len characters of the
+ * string s in the history list, starting at h_start and ending at
+ * h_end, or NULL if there isn't one. */
+filestruct *find_history(const filestruct *h_start, const filestruct
+	*h_end, const char *s, size_t len)
+{
+    const filestruct *p;
+
+    for (p = h_start; p != h_end->next && p != NULL; p = p->next) {
+	if (strncmp(s, p->data, len) == 0)
+	    return (filestruct *)p;
+    }
+
+    return NULL;
+}
+
+/* Update a history list.  h should be the current position in the
+ * list. */
+void update_history(filestruct **h, const char *s)
+{
+    filestruct **hage = NULL, **hbot = NULL, *p;
+
+    assert(h != NULL && s != NULL);
+
+    if (*h == search_history) {
+	hage = &searchage;
+	hbot = &searchbot;
+    } else if (*h == replace_history) {
+	hage = &replaceage;
+	hbot = &replacebot;
+    }
+
+    assert(hage != NULL && hbot != NULL);
+
+    /* If this string is already in the history, delete it. */
+    p = find_history(*hage, *hbot, s, strlen(s));
+
+    if (p != NULL) {
+	filestruct *foo, *bar;
+
+	/* If the string is at the beginning, move the beginning down to
+	 * the next string. */
+	if (p == *hage)
+	    *hage = (*hage)->next;
+
+	/* Delete the string. */
+	foo = p;
+	bar = p->next;
+	unlink_node(foo);
+	delete_node(foo);
+	if (bar != NULL)
+	    renumber(bar);
+    }
+
+    /* If the history is full, delete the beginning entry to make room
+     * for the new entry at the end.  We assume that MAX_SEARCH_HISTORY
+     * is greater than zero. */
+    if ((*hbot)->lineno == MAX_SEARCH_HISTORY + 1) {
+	filestruct *foo = *hage;
+
+	*hage = (*hage)->next;
+	unlink_node(foo);
+	delete_node(foo);
+	renumber(*hage);
+    }
+
+    /* Add the new entry to the end. */
+    (*hbot)->data = mallocstrcpy((*hbot)->data, s);
+    splice_node(*hbot, make_new_node(*hbot), (*hbot)->next);
+    *hbot = (*hbot)->next;
+    (*hbot)->data = mallocstrcpy(NULL, "");
+
+#ifdef ENABLE_NANORC
+    /* Indicate that the history's been changed. */
+    history_changed = TRUE;
+#endif
+
+    /* Set the current position in the list to the bottom. */
+    *h = *hbot;
+}
+
+/* Move h to the string in the history list just before it, and return
+ * that string.  If there isn't one, don't move h and return NULL. */
+char *get_history_older(filestruct **h)
+{
+    assert(h != NULL);
+
+    if ((*h)->prev == NULL)
+	return NULL;
+
+    *h = (*h)->prev;
+
+    return (*h)->data;
+}
+
+/* Move h to the string in the history list just after it, and return
+ * that string.  If there isn't one, don't move h and return NULL. */
+char *get_history_newer(filestruct **h)
+{
+    assert(h != NULL);
+
+    if ((*h)->next == NULL)
+	return NULL;
+
+    *h = (*h)->next;
+
+    return (*h)->data;
+}
+
+/* More placeholders */
+void get_history_newer_void(void)
+{
+    ;
+}
+void get_history_older_void(void)
+{
+    ;
+}
+
+#ifndef DISABLE_TABCOMP
+/* Move h to the next string that's a tab completion of the string s,
+ * looking at only the first len characters of s, and return that
+ * string.  If there isn't one, or if len is 0, don't move h and return
+ * s. */
+char *get_history_completion(filestruct **h, const char *s, size_t len)
+{
+    assert(s != NULL);
+
+    if (len > 0) {
+	filestruct *hage = NULL, *hbot = NULL, *p;
+
+	assert(h != NULL);
+
+	if (*h == search_history) {
+	    hage = searchage;
+	    hbot = searchbot;
+	} else if (*h == replace_history) {
+	    hage = replaceage;
+	    hbot = replacebot;
+	}
+
+	assert(hage != NULL && hbot != NULL);
+
+	/* Search the history list from the current position to the
+	 * bottom for a match of len characters.  Skip over an exact
+	 * match. */
+	p = find_history((*h)->next, hbot, s, len);
+
+	while (p != NULL && strcmp(p->data, s) == 0)
+	    p = find_history(p->next, hbot, s, len);
+
+	if (p != NULL) {
+	    *h = p;
+	    return (*h)->data;
+	}
+
+	/* Search the history list from the top to the current position
+	 * for a match of len characters.  Skip over an exact match. */
+	p = find_history(hage, *h, s, len);
+
+	while (p != NULL && strcmp(p->data, s) == 0)
+	    p = find_history(p->next, *h, s, len);
+
+	if (p != NULL) {
+	    *h = p;
+	    return (*h)->data;
+	}
+    }
+
+    /* If we're here, we didn't find a match, we didn't find an inexact
+     * match, or len is 0.  Return s. */
+    return (char *)s;
+}
+#endif /* !DISABLE_TABCOMP */
+#endif /* !NANO_TINY */
diff --git a/src/text.c b/src/text.c
new file mode 100644
index 0000000..7abe712
--- /dev/null
+++ b/src/text.c
@@ -0,0 +1,3079 @@
+/* $Id: text.c 4544 2011-05-10 05:43:08Z 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 == UNdel_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 & UNsplit_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 += extra;
+    }
+#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;
+}
+
+/* Need this again... */
+void do_enter_void(void) {
+    do_enter(FALSE);
+}
+
+#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 = UNdel_del;
+	    else if (u->xflags != UNdel_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 = UNdel_backspace;
+	    else if (u->xflags != UNdel_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 = UNsplit_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(&quotereg, 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(&quote_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);
+}
+
diff --git a/src/utils.c b/src/utils.c
new file mode 100644
index 0000000..ff13a41
--- /dev/null
+++ b/src/utils.c
@@ -0,0 +1,674 @@
+/* $Id: utils.c 4453 2009-12-02 03:36:22Z astyanax $ */
+/**************************************************************************
+ *   utils.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 <string.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <pwd.h>
+#include <ctype.h>
+#include <errno.h>
+
+/* Return the number of decimal digits in n. */
+int digits(size_t n)
+{
+    int i;
+
+    if (n == 0)
+	i = 1;
+    else {
+	for (i = 0; n != 0; n /= 10, i++)
+	    ;
+    }
+
+    return i;
+}
+
+/* Return the user's home directory.  We use $HOME, and if that fails,
+ * we fall back on the home directory of the effective user ID. */
+void get_homedir(void)
+{
+    if (homedir == NULL) {
+	const char *homenv = getenv("HOME");
+
+	if (homenv == NULL) {
+	    const struct passwd *userage = getpwuid(geteuid());
+
+	    if (userage != NULL)
+		homenv = userage->pw_dir;
+	}
+	homedir = mallocstrcpy(NULL, homenv);
+    }
+}
+
+/* Read a ssize_t from str, and store it in *val (if val is not NULL).
+ * On error, we return FALSE and don't change *val.  Otherwise, we
+ * return TRUE. */
+bool parse_num(const char *str, ssize_t *val)
+{
+    char *first_error;
+    ssize_t j;
+
+    assert(str != NULL);
+
+    j = (ssize_t)strtol(str, &first_error, 10);
+
+    if (errno == ERANGE || *str == '\0' || *first_error != '\0')
+	return FALSE;
+
+    if (val != NULL)
+	*val = j;
+
+    return TRUE;
+}
+
+/* Read two ssize_t's, separated by a comma, from str, and store them in
+ * *line and *column (if they're not both NULL).  Return FALSE on error,
+ * or TRUE otherwise. */
+bool parse_line_column(const char *str, ssize_t *line, ssize_t *column)
+{
+    bool retval = TRUE;
+    const char *comma;
+
+    assert(str != NULL);
+
+    comma = strchr(str, ',');
+
+    if (comma != NULL && column != NULL) {
+	if (!parse_num(comma + 1, column))
+	    retval = FALSE;
+    }
+
+    if (line != NULL) {
+	if (comma != NULL) {
+	    char *str_line = mallocstrncpy(NULL, str, comma - str + 1);
+	    str_line[comma - str] = '\0';
+
+	    if (str_line[0] != '\0' && !parse_num(str_line, line))
+		retval = FALSE;
+
+	    free(str_line);
+	} else if (!parse_num(str, line))
+	    retval = FALSE;
+    }
+
+    return retval;
+}
+
+/* Fix the memory allocation for a string. */
+void align(char **str)
+{
+    assert(str != NULL);
+
+    if (*str != NULL)
+	*str = charealloc(*str, strlen(*str) + 1);
+}
+
+/* Null a string at a certain index and align it. */
+void null_at(char **data, size_t index)
+{
+    assert(data != NULL);
+
+    *data = charealloc(*data, index + 1);
+    (*data)[index] = '\0';
+}
+
+/* For non-null-terminated lines.  A line, by definition, shouldn't
+ * normally have newlines in it, so encode its nulls as newlines. */
+void unsunder(char *str, size_t true_len)
+{
+    assert(str != NULL);
+
+    for (; true_len > 0; true_len--, str++) {
+	if (*str == '\0')
+	    *str = '\n';
+    }
+}
+
+/* For non-null-terminated lines.  A line, by definition, shouldn't
+ * normally have newlines in it, so decode its newlines as nulls. */
+void sunder(char *str)
+{
+    assert(str != NULL);
+
+    for (; *str != '\0'; str++) {
+	if (*str == '\n')
+	    *str = '\0';
+    }
+}
+
+/* These functions, ngetline() (originally getline()) and ngetdelim()
+ * (originally getdelim()), were adapted from GNU mailutils 0.5
+ * (mailbox/getline.c).  Here is the notice from that file, after
+ * converting to the GPL via LGPL clause 3, and with the Free Software
+ * Foundation's address and the copyright years updated:
+ *
+ * GNU Mailutils -- a suite of utilities for electronic mail
+ * Copyright (C) 1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007
+ * Free Software Foundation, Inc.
+ *
+ * This library 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.
+ *
+ * This library 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 library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301, USA. */
+
+#ifdef ENABLE_NANORC
+
+#ifndef HAVE_GETDELIM
+/* This function is equivalent to getdelim(). */
+ssize_t ngetdelim(char **lineptr, size_t *n, int delim, FILE *stream)
+{
+    size_t indx = 0;
+    int c;
+
+    /* Sanity checks. */
+    if (lineptr == NULL || n == NULL || stream == NULL ||
+	fileno(stream) == -1) {
+	errno = EINVAL;
+	return -1;
+    }
+
+    /* Allocate the line the first time. */
+    if (*lineptr == NULL) {
+	*n = MAX_BUF_SIZE;
+	*lineptr = charalloc(*n);
+    }
+
+    while ((c = getc(stream)) != EOF) {
+	/* Check if more memory is needed. */
+	if (indx >= *n) {
+	    *n += MAX_BUF_SIZE;
+	    *lineptr = charealloc(*lineptr, *n);
+	}
+
+	/* Put the result in the line. */
+	(*lineptr)[indx++] = (char)c;
+
+	/* Bail out. */
+	if (c == delim)
+	    break;
+    }
+
+    /* Make room for the null character. */
+    if (indx >= *n) {
+	*n += MAX_BUF_SIZE;
+	*lineptr = charealloc(*lineptr, *n);
+    }
+
+    /* Null-terminate the buffer. */
+    null_at(lineptr, indx++);
+    *n = indx;
+
+    /* The last line may not have the delimiter.  We have to return what
+     * we got, and the error will be seen on the next iteration. */
+    return (c == EOF && (indx - 1) == 0) ? -1 : indx - 1;
+}
+#endif
+
+#ifndef HAVE_GETLINE
+/* This function is equivalent to getline(). */
+ssize_t ngetline(char **lineptr, size_t *n, FILE *stream)
+{
+    return getdelim(lineptr, n, '\n', stream);
+}
+#endif
+#endif /* ENABLE_NANORC */
+
+#ifdef HAVE_REGEX_H
+/* Do the compiled regex in preg and the regex in string match the
+ * beginning or end of a line? */
+bool regexp_bol_or_eol(const regex_t *preg, const char *string)
+{
+    return (regexec(preg, string, 0, NULL, 0) == 0 &&
+	regexec(preg, string, 0, NULL, REG_NOTBOL | REG_NOTEOL) ==
+	REG_NOMATCH);
+}
+
+/* Fix the regex if we're on platforms which requires an adjustment
+ * from GNU-style to BSD-style word boundaries.  */
+const char *fixbounds(const char *r) {
+#ifndef GNU_WORDBOUNDS
+    int i, j = 0;
+    char *r2 = charalloc(strlen(r) * 5);
+    char *r3;
+
+#ifdef DEBUG
+    fprintf(stderr, "fixbounds(): Start string = \"%s\"\n", r);
+#endif
+
+    for (i = 0; i < strlen(r); i++) {
+        if (r[i] != '\0' && r[i] == '\\' && (r[i+1] == '>' || r[i+1] == '<')) {
+            strcpy(&r2[j], "[[:");
+            r2[j+3] = r[i+1];
+            strcpy(&r2[j+4], ":]]");
+            i++;
+            j += 6;
+        } else
+            r2[j] = r[i];
+        j++;
+    }
+    r2[j] = '\0';
+    r3 = mallocstrcpy(NULL, r2);
+    free(r2);
+#ifdef DEBUG
+    fprintf(stderr, "fixbounds(): Ending string = \"%s\"\n", r3);
+#endif
+    return (const char *) r3;
+#endif
+
+    return r;
+}
+
+#endif
+
+#ifndef DISABLE_SPELLER
+/* Is the word starting at position pos in buf a whole word? */
+bool is_whole_word(size_t pos, const char *buf, const char *word)
+{
+    char *p = charalloc(mb_cur_max()), *r = charalloc(mb_cur_max());
+    size_t word_end = pos + strlen(word);
+    bool retval;
+
+    assert(buf != NULL && pos <= strlen(buf) && word != NULL);
+
+    parse_mbchar(buf + move_mbleft(buf, pos), p, NULL);
+    parse_mbchar(buf + word_end, r, NULL);
+
+    /* If we're at the beginning of the line or the character before the
+     * word isn't a non-punctuation "word" character, and if we're at
+     * the end of the line or the character after the word isn't a
+     * non-punctuation "word" character, we have a whole word. */
+    retval = (pos == 0 || !is_word_mbchar(p, FALSE)) &&
+	(word_end == strlen(buf) || !is_word_mbchar(r, FALSE));
+
+    free(p);
+    free(r);
+
+    return retval;
+}
+#endif /* !DISABLE_SPELLER */
+
+/* If we are searching backwards, we will find the last match that
+ * starts no later than start.  Otherwise we find the first match
+ * starting no earlier than start.  If we are doing a regexp search, we
+ * fill in the global variable regmatches with at most 9 subexpression
+ * matches.  Also, all .rm_so elements are relative to the start of the
+ * whole match, so regmatches[0].rm_so == 0. */
+const char *strstrwrapper(const char *haystack, const char *needle,
+	const char *start)
+{
+    /* start can be 1 character before the start or after the end of the
+     * line.  In either case, we just say no match was found. */
+    if ((start > haystack && *(start - 1) == '\0') || start < haystack)
+	return NULL;
+
+    assert(haystack != NULL && needle != NULL && start != NULL);
+
+#ifdef HAVE_REGEX_H
+    if (ISSET(USE_REGEXP)) {
+#ifndef NANO_TINY
+	if (ISSET(BACKWARDS_SEARCH)) {
+	    if (regexec(&search_regexp, haystack, 1, regmatches,
+		0) == 0 && haystack + regmatches[0].rm_so <= start) {
+		const char *retval = haystack + regmatches[0].rm_so;
+
+		/* Search forward until there are no more matches. */
+		while (regexec(&search_regexp, retval + 1, 1,
+			regmatches, REG_NOTBOL) == 0 &&
+			retval + regmatches[0].rm_so + 1 <= start)
+		    retval += regmatches[0].rm_so + 1;
+		/* Finally, put the subexpression matches in global
+		 * variable regmatches.  The REG_NOTBOL flag doesn't
+		 * matter now. */
+		regexec(&search_regexp, retval, 10, regmatches, 0);
+		return retval;
+	    }
+	} else
+#endif /* !NANO_TINY */
+	if (regexec(&search_regexp, start, 10, regmatches,
+		(start > haystack) ? REG_NOTBOL : 0) == 0) {
+	    const char *retval = start + regmatches[0].rm_so;
+
+	    regexec(&search_regexp, retval, 10, regmatches, 0);
+	    return retval;
+	}
+	return NULL;
+    }
+#endif /* HAVE_REGEX_H */
+#if !defined(NANO_TINY) || !defined(DISABLE_SPELLER)
+    if (ISSET(CASE_SENSITIVE)) {
+#ifndef NANO_TINY
+	if (ISSET(BACKWARDS_SEARCH))
+	    return revstrstr(haystack, needle, start);
+	else
+#endif
+	    return strstr(start, needle);
+    }
+#endif /* !DISABLE_SPELLER || !NANO_TINY */
+#ifndef NANO_TINY
+    else if (ISSET(BACKWARDS_SEARCH))
+	return mbrevstrcasestr(haystack, needle, start);
+#endif
+    return mbstrcasestr(start, needle);
+}
+
+/* This is a wrapper for the perror() function.  The wrapper temporarily
+ * leaves curses mode, calls perror() (which writes to stderr), and then
+ * reenters curses mode, updating the screen in the process.  Note that
+ * nperror() causes the window to flicker once. */
+void nperror(const char *s)
+{
+    endwin();
+    perror(s);
+    doupdate();
+}
+
+/* This is a wrapper for the malloc() function that properly handles
+ * things when we run out of memory.  Thanks, BG, many people have been
+ * asking for this... */
+void *nmalloc(size_t howmuch)
+{
+    void *r = malloc(howmuch);
+
+    if (r == NULL && howmuch != 0)
+	die(_("nano is out of memory!"));
+
+    return r;
+}
+
+/* This is a wrapper for the realloc() function that properly handles
+ * things when we run out of memory. */
+void *nrealloc(void *ptr, size_t howmuch)
+{
+    void *r = realloc(ptr, howmuch);
+
+    if (r == NULL && howmuch != 0)
+	die(_("nano is out of memory!"));
+
+    return r;
+}
+
+/* Copy the first n characters of one malloc()ed string to another
+ * pointer.  Should be used as: "dest = mallocstrncpy(dest, src,
+ * n);". */
+char *mallocstrncpy(char *dest, const char *src, size_t n)
+{
+    if (src == NULL)
+	src = "";
+
+    if (src != dest)
+	free(dest);
+
+    dest = charalloc(n);
+    strncpy(dest, src, n);
+
+    return dest;
+}
+
+/* Copy one malloc()ed string to another pointer.  Should be used as:
+ * "dest = mallocstrcpy(dest, src);". */
+char *mallocstrcpy(char *dest, const char *src)
+{
+    return mallocstrncpy(dest, src, (src == NULL) ? 1 :
+	strlen(src) + 1);
+}
+
+/* Free the malloc()ed string at dest and return the malloc()ed string
+ * at src.  Should be used as: "answer = mallocstrassn(answer,
+ * real_dir_from_tilde(answer));". */
+char *mallocstrassn(char *dest, char *src)
+{
+    free(dest);
+    return src;
+}
+
+/* nano scrolls horizontally within a line in chunks.  Return the column
+ * number of the first character displayed in the edit window when the
+ * cursor is at the given column.  Note that (0 <= column -
+ * get_page_start(column) < COLS). */
+size_t get_page_start(size_t column)
+{
+    if (column == 0 || column < COLS - 1)
+	return 0;
+    else if (COLS > 8)
+	return column - 7 - (column - 7) % (COLS - 8);
+    else
+	return column - (COLS - 2);
+}
+
+/* Return the placewewant associated with current_x, i.e. the zero-based
+ * column position of the cursor.  The value will be no smaller than
+ * current_x. */
+size_t xplustabs(void)
+{
+    return strnlenpt(openfile->current->data, openfile->current_x);
+}
+
+/* Return the index in s of the character displayed at the given column,
+ * i.e. the largest value such that strnlenpt(s, actual_x(s, column)) <=
+ * column. */
+size_t actual_x(const char *s, size_t column)
+{
+    size_t i = 0;
+	/* The position in s, returned. */
+    size_t len = 0;
+	/* The screen display width to s[i]. */
+
+    assert(s != NULL);
+
+    while (*s != '\0') {
+	int s_len = parse_mbchar(s, NULL, &len);
+
+	if (len > column)
+	    break;
+
+	i += s_len;
+	s += s_len;
+    }
+
+    return i;
+}
+
+/* A strnlen() with tabs and multicolumn characters factored in, similar
+ * to xplustabs().  How many columns wide are the first maxlen characters
+ * of s? */
+size_t strnlenpt(const char *s, size_t maxlen)
+{
+    size_t len = 0;
+	/* The screen display width to s[i]. */
+
+    if (maxlen == 0)
+	return 0;
+
+    assert(s != NULL);
+
+    while (*s != '\0') {
+	int s_len = parse_mbchar(s, NULL, &len);
+
+	s += s_len;
+
+	if (maxlen <= s_len)
+	    break;
+
+	maxlen -= s_len;
+    }
+
+    return len;
+}
+
+/* A strlen() with tabs and multicolumn characters factored in, similar
+ * to xplustabs().  How many columns wide is s? */
+size_t strlenpt(const char *s)
+{
+    return strnlenpt(s, (size_t)-1);
+}
+
+/* Append a new magicline to filebot. */
+void new_magicline(void)
+{
+    openfile->filebot->next = (filestruct *)nmalloc(sizeof(filestruct));
+    openfile->filebot->next->data = mallocstrcpy(NULL, "");
+    openfile->filebot->next->prev = openfile->filebot;
+    openfile->filebot->next->next = NULL;
+    openfile->filebot->next->lineno = openfile->filebot->lineno + 1;
+#ifdef ENABLE_COLOR
+    openfile->filebot->next->multidata = NULL;
+#endif
+    openfile->filebot = openfile->filebot->next;
+    openfile->totsize++;
+}
+
+#ifndef NANO_TINY
+/* Remove the magicline from filebot, if there is one and it isn't the
+ * only line in the file.  Assume that edittop and current are not at
+ * filebot. */
+void remove_magicline(void)
+{
+    if (openfile->filebot->data[0] == '\0' &&
+	openfile->filebot != openfile->fileage) {
+	assert(openfile->filebot != openfile->edittop && openfile->filebot != openfile->current);
+
+	openfile->filebot = openfile->filebot->prev;
+	free_filestruct(openfile->filebot->next);
+	openfile->filebot->next = NULL;
+	openfile->totsize--;
+    }
+}
+
+/* Set top_x and bot_x to the top and bottom x-coordinates of the mark,
+ * respectively, based on the locations of top and bot.  If
+ * right_side_up isn't NULL, set it to TRUE if the mark begins with
+ * (mark_begin, mark_begin_x) and ends with (current, current_x), or
+ * FALSE otherwise. */
+void mark_order(const filestruct **top, size_t *top_x, const filestruct
+	**bot, size_t *bot_x, bool *right_side_up)
+{
+    assert(top != NULL && top_x != NULL && bot != NULL && bot_x != NULL);
+
+    if ((openfile->current->lineno == openfile->mark_begin->lineno &&
+	openfile->current_x > openfile->mark_begin_x) ||
+	openfile->current->lineno > openfile->mark_begin->lineno) {
+	*top = openfile->mark_begin;
+	*top_x = openfile->mark_begin_x;
+	*bot = openfile->current;
+	*bot_x = openfile->current_x;
+	if (right_side_up != NULL)
+	    *right_side_up = TRUE;
+    } else {
+	*bot = openfile->mark_begin;
+	*bot_x = openfile->mark_begin_x;
+	*top = openfile->current;
+	*top_x = openfile->current_x;
+	if (right_side_up != NULL)
+	    *right_side_up = FALSE;
+    }
+}
+#endif
+
+/* Calculate the number of characters between begin and end, and return
+ * it. */
+size_t get_totsize(const filestruct *begin, const filestruct *end)
+{
+    size_t totsize = 0;
+    const filestruct *f;
+
+    /* Go through the lines from begin to end->prev, if we can. */
+    for (f = begin; f != end && f != NULL; f = f->next) {
+	/* Count the number of characters on this line. */
+	totsize += mbstrlen(f->data);
+
+	/* Count the newline if we have one. */
+	if (f->next != NULL)
+	    totsize++;
+    }
+
+    /* Go through the line at end, if we can. */
+    if (f != NULL) {
+	/* Count the number of characters on this line. */
+	totsize += mbstrlen(f->data);
+
+	/* Count the newline if we have one. */
+	if (f->next != NULL)
+	    totsize++;
+    }
+
+    return totsize;
+}
+
+/* Get back a pointer given a line number in the current openfilestruct */
+filestruct *fsfromline(ssize_t lineno)
+{
+    filestruct *f = openfile->current;
+
+    if (lineno <= openfile->current->lineno)
+	for (; f->lineno != lineno && f != openfile->fileage; f = f->prev)
+	   ;
+    else
+        for (; f->lineno != lineno && f->next != NULL; f = f->next)
+	    ;
+
+    if (f->lineno != lineno)
+	f = NULL;
+    return f;
+}
+
+#ifdef DEBUG
+/* Dump the filestruct inptr to stderr. */
+void dump_filestruct(const filestruct *inptr)
+{
+    if (inptr == openfile->fileage)
+	fprintf(stderr, "Dumping file buffer to stderr...\n");
+    else if (inptr == cutbuffer)
+	fprintf(stderr, "Dumping cutbuffer to stderr...\n");
+    else
+	fprintf(stderr, "Dumping a buffer to stderr...\n");
+
+    while (inptr != NULL) {
+	fprintf(stderr, "(%ld) %s\n", (long)inptr->lineno, inptr->data);
+	inptr = inptr->next;
+    }
+}
+
+/* Dump the current buffer's filestruct to stderr in reverse. */
+void dump_filestruct_reverse(void)
+{
+    const filestruct *fileptr = openfile->filebot;
+
+    while (fileptr != NULL) {
+	fprintf(stderr, "(%ld) %s\n", (long)fileptr->lineno,
+		fileptr->data);
+	fileptr = fileptr->prev;
+    }
+}
+#endif /* DEBUG */
diff --git a/src/winio.c b/src/winio.c
new file mode 100644
index 0000000..3ad7fb1
--- /dev/null
+++ b/src/winio.c
@@ -0,0 +1,3586 @@
+/* $Id: winio.c 4527 2011-02-07 14:45:56Z astyanax $ */
+/**************************************************************************
+ *   winio.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 <stdarg.h>
+#include <string.h>
+#include <unistd.h>
+#include <ctype.h>
+
+static int *key_buffer = NULL;
+	/* The keystroke buffer, containing all the keystrokes we
+	 * haven't handled yet at a given point. */
+static size_t key_buffer_len = 0;
+	/* The length of the keystroke buffer. */
+static int statusblank = 0;
+	/* The number of keystrokes left after we call statusbar(),
+	 * before we actually blank the statusbar. */
+static bool disable_cursorpos = FALSE;
+	/* Should we temporarily disable constant cursor position
+	 * display? */
+
+/* Control character compatibility:
+ *
+ * - NANO_BACKSPACE_KEY is Ctrl-H, which is Backspace under ASCII, ANSI,
+ *   VT100, and VT220.
+ * - NANO_TAB_KEY is Ctrl-I, which is Tab under ASCII, ANSI, VT100,
+ *   VT220, and VT320.
+ * - NANO_ENTER_KEY is Ctrl-M, which is Enter under ASCII, ANSI, VT100,
+ *   VT220, and VT320.
+ * - NANO_XON_KEY is Ctrl-Q, which is XON under ASCII, ANSI, VT100,
+ *   VT220, and VT320.
+ * - NANO_XOFF_KEY is Ctrl-S, which is XOFF under ASCII, ANSI, VT100,
+ *   VT220, and VT320.
+ * - NANO_CONTROL_8 is Ctrl-8 (Ctrl-?), which is Delete under ASCII,
+ *   ANSI, VT100, and VT220, and which is Backspace under VT320.
+ *
+ * Note: VT220 and VT320 also generate Esc [ 3 ~ for Delete.  By
+ * default, xterm assumes it's running on a VT320 and generates Ctrl-8
+ * (Ctrl-?) for Backspace and Esc [ 3 ~ for Delete.  This causes
+ * problems for VT100-derived terminals such as the FreeBSD console,
+ * which expect Ctrl-H for Backspace and Ctrl-8 (Ctrl-?) for Delete, and
+ * on which the VT320 sequences are translated by the keypad to KEY_DC
+ * and [nothing].  We work around this conflict via the REBIND_DELETE
+ * flag: if it's not set, we assume VT320 compatibility, and if it is,
+ * we assume VT100 compatibility.  Thanks to Lee Nelson and Wouter van
+ * Hemel for helping work this conflict out.
+ *
+ * Escape sequence compatibility:
+ *
+ * We support escape sequences for ANSI, VT100, VT220, VT320, the Linux
+ * console, the FreeBSD console, the Mach console, xterm, rxvt, Eterm,
+ * and Terminal.  Among these, there are several conflicts and
+ * omissions, outlined as follows:
+ *
+ * - Tab on ANSI == PageUp on FreeBSD console; the former is omitted.
+ *   (Ctrl-I is also Tab on ANSI, which we already support.)
+ * - PageDown on FreeBSD console == Center (5) on numeric keypad with
+ *   NumLock off on Linux console; the latter is omitted.  (The editing
+ *   keypad key is more important to have working than the numeric
+ *   keypad key, because the latter has no value when NumLock is off.)
+ * - F1 on FreeBSD console == the mouse key on xterm/rxvt/Eterm; the
+ *   latter is omitted.  (Mouse input will only work properly if the
+ *   extended keypad value KEY_MOUSE is generated on mouse events
+ *   instead of the escape sequence.)
+ * - F9 on FreeBSD console == PageDown on Mach console; the former is
+ *   omitted.  (The editing keypad is more important to have working
+ *   than the function keys, because the functions of the former are not
+ *   arbitrary and the functions of the latter are.)
+ * - F10 on FreeBSD console == PageUp on Mach console; the former is
+ *   omitted.  (Same as above.)
+ * - F13 on FreeBSD console == End on Mach console; the former is
+ *   omitted.  (Same as above.)
+ * - F15 on FreeBSD console == Shift-Up on rxvt/Eterm; the former is
+ *   omitted.  (The arrow keys, with or without modifiers, are more
+ *   important to have working than the function keys, because the
+ *   functions of the former are not arbitrary and the functions of the
+ *   latter are.)
+ * - F16 on FreeBSD console == Shift-Down on rxvt/Eterm; the former is
+ *   omitted.  (Same as above.) */
+
+/* Read in a sequence of keystrokes from win and save them in the
+ * keystroke buffer.  This should only be called when the keystroke
+ * buffer is empty. */
+void get_key_buffer(WINDOW *win)
+{
+    int input;
+    size_t errcount;
+
+    /* If the keystroke buffer isn't empty, get out. */
+    if (key_buffer != NULL)
+	return;
+
+    /* Read in the first character using blocking input. */
+#ifndef NANO_TINY
+    allow_pending_sigwinch(TRUE);
+#endif
+
+    /* Just before reading in the first character, display any pending
+     * screen updates. */
+    doupdate();
+
+    errcount = 0;
+    if (nodelay_mode) {
+	if ((input =  wgetch(win)) == ERR)
+           return;
+    } else
+	while ((input = wgetch(win)) == ERR) {
+	    errcount++;
+
+	    /* If we've failed to get a character MAX_BUF_SIZE times in a
+	     * row, assume that the input source we were using is gone and
+	     * die gracefully.  We could check if errno is set to EIO
+	     * ("Input/output error") and die gracefully in that case, but
+	     * it's not always set properly.  Argh. */
+	    if (errcount == MAX_BUF_SIZE)
+		handle_hupterm(0);
+	}
+
+#ifndef NANO_TINY
+    allow_pending_sigwinch(FALSE);
+#endif
+
+    /* Increment the length of the keystroke buffer, and save the value
+     * of the keystroke at the end of it. */
+    key_buffer_len++;
+    key_buffer = (int *)nmalloc(sizeof(int));
+    key_buffer[0] = input;
+
+    /* Read in the remaining characters using non-blocking input. */
+    nodelay(win, TRUE);
+
+    while (TRUE) {
+#ifndef NANO_TINY
+	allow_pending_sigwinch(TRUE);
+#endif
+
+	input = wgetch(win);
+
+	/* If there aren't any more characters, stop reading. */
+	if (input == ERR)
+	    break;
+
+	/* Otherwise, increment the length of the keystroke buffer, and
+	 * save the value of the keystroke at the end of it. */
+	key_buffer_len++;
+	key_buffer = (int *)nrealloc(key_buffer, key_buffer_len *
+		sizeof(int));
+	key_buffer[key_buffer_len - 1] = input;
+
+#ifndef NANO_TINY
+	allow_pending_sigwinch(FALSE);
+#endif
+    }
+
+    /* Switch back to non-blocking input. */
+    nodelay(win, FALSE);
+
+#ifdef DEBUG
+    fprintf(stderr, "get_key_buffer(): key_buffer_len = %lu\n", (unsigned long)key_buffer_len);
+#endif
+}
+
+/* Return the length of the keystroke buffer. */
+size_t get_key_buffer_len(void)
+{
+    return key_buffer_len;
+}
+
+/* Add the keystrokes in input to the keystroke buffer. */
+void unget_input(int *input, size_t input_len)
+{
+#ifndef NANO_TINY
+    allow_pending_sigwinch(TRUE);
+    allow_pending_sigwinch(FALSE);
+#endif
+
+    /* If input is empty, get out. */
+    if (input_len == 0)
+	return;
+
+    /* If adding input would put the keystroke buffer beyond maximum
+     * capacity, only add enough of input to put it at maximum
+     * capacity. */
+    if (key_buffer_len + input_len < key_buffer_len)
+	input_len = (size_t)-1 - key_buffer_len;
+
+    /* Add the length of input to the length of the keystroke buffer,
+     * and reallocate the keystroke buffer so that it has enough room
+     * for input. */
+    key_buffer_len += input_len;
+    key_buffer = (int *)nrealloc(key_buffer, key_buffer_len *
+	sizeof(int));
+
+    /* If the keystroke buffer wasn't empty before, move its beginning
+     * forward far enough so that we can add input to its beginning. */
+    if (key_buffer_len > input_len)
+	memmove(key_buffer + input_len, key_buffer,
+		(key_buffer_len - input_len) * sizeof(int));
+
+    /* Copy input to the beginning of the keystroke buffer. */
+    memcpy(key_buffer, input, input_len * sizeof(int));
+}
+
+/* Put back the character stored in kbinput, putting it in byte range
+ * beforehand.  If meta_key is TRUE, put back the Escape character after
+ * putting back kbinput.  If func_key is TRUE, put back the function key
+ * (a value outside byte range) without putting it in byte range. */
+void unget_kbinput(int kbinput, bool meta_key, bool func_key)
+{
+    if (!func_key)
+	kbinput = (char)kbinput;
+
+    unget_input(&kbinput, 1);
+
+    if (meta_key) {
+	kbinput = NANO_CONTROL_3;
+	unget_input(&kbinput, 1);
+    }
+}
+
+/* Try to read input_len characters from the keystroke buffer.  If the
+ * keystroke buffer is empty and win isn't NULL, try to read in more
+ * characters from win and add them to the keystroke buffer before doing
+ * anything else.  If the keystroke buffer is empty and win is NULL,
+ * return NULL. */
+int *get_input(WINDOW *win, size_t input_len)
+{
+    int *input;
+
+#ifndef NANO_TINY
+    allow_pending_sigwinch(TRUE);
+    allow_pending_sigwinch(FALSE);
+#endif
+
+    if (key_buffer_len == 0) {
+	if (win != NULL) {
+	    get_key_buffer(win);
+
+	    if (key_buffer_len == 0)
+		return NULL;
+	} else
+	    return NULL;
+    }
+
+    /* If input_len is greater than the length of the keystroke buffer,
+     * only read the number of characters in the keystroke buffer. */
+    if (input_len > key_buffer_len)
+	input_len = key_buffer_len;
+
+    /* Subtract input_len from the length of the keystroke buffer, and
+     * allocate input so that it has enough room for input_len
+     * keystrokes. */
+    key_buffer_len -= input_len;
+    input = (int *)nmalloc(input_len * sizeof(int));
+
+    /* Copy input_len keystrokes from the beginning of the keystroke
+     * buffer into input. */
+    memcpy(input, key_buffer, input_len * sizeof(int));
+
+    /* If the keystroke buffer is empty, mark it as such. */
+    if (key_buffer_len == 0) {
+	free(key_buffer);
+	key_buffer = NULL;
+    /* If the keystroke buffer isn't empty, move its beginning forward
+     * far enough so that the keystrokes in input are no longer at its
+     * beginning. */
+    } else {
+	memmove(key_buffer, key_buffer + input_len, key_buffer_len *
+		sizeof(int));
+	key_buffer = (int *)nrealloc(key_buffer, key_buffer_len *
+		sizeof(int));
+    }
+
+    return input;
+}
+
+/* Read in a single character.  If it's ignored, swallow it and go on.
+ * Otherwise, try to translate it from ASCII, meta key sequences, escape
+ * sequences, and/or extended keypad values.  Set meta_key to TRUE when
+ * we get a meta key sequence, and set func_key to TRUE when we get an
+ * extended keypad value.  Supported extended keypad values consist of
+ * [arrow key], Ctrl-[arrow key], Shift-[arrow key], Enter, Backspace,
+ * the editing keypad (Insert, Delete, Home, End, PageUp, and PageDown),
+ * the function keypad (F1-F16), and the numeric keypad with NumLock
+ * off.  Assume nodelay(win) is FALSE. */
+int get_kbinput(WINDOW *win, bool *meta_key, bool *func_key)
+{
+    int kbinput;
+
+    /* Read in a character and interpret it.  Continue doing this until
+     * we get a recognized value or sequence. */
+    while ((kbinput = parse_kbinput(win, meta_key, func_key)) == ERR);
+
+    /* If we read from the edit window, blank the statusbar if we need
+     * to. */
+    if (win == edit)
+	check_statusblank();
+
+    return kbinput;
+}
+
+/* Translate ASCII characters, extended keypad values, and escape
+ * sequences into their corresponding key values.  Set meta_key to TRUE
+ * when we get a meta key sequence, and set func_key to TRUE when we get
+ * a function key.  Assume nodelay(win) is FALSE. */
+int parse_kbinput(WINDOW *win, bool *meta_key, bool *func_key)
+{
+    static int escapes = 0, byte_digits = 0;
+    int *kbinput, retval = ERR;
+
+    *meta_key = FALSE;
+    *func_key = FALSE;
+
+    /* Read in a character. */
+    if (nodelay_mode) {
+	kbinput = get_input(win, 1);
+	if (kbinput == 0)
+	    return 0;
+    } else
+	while ((kbinput = get_input(win, 1)) == NULL);
+
+    switch (*kbinput) {
+	case ERR:
+	    break;
+	case NANO_CONTROL_3:
+	    /* Increment the escape counter. */
+	    escapes++;
+	    switch (escapes) {
+		case 1:
+		    /* One escape: wait for more input. */
+		case 2:
+		    /* Two escapes: wait for more input. */
+		case 3:
+		    /* Three escapes: wait for more input. */
+		    break;
+		default:
+		    /* More than three escapes: limit the escape counter
+		     * to no more than two, and wait for more input. */
+		    escapes %= 3;
+	    }
+	    break;
+	default:
+	    switch (escapes) {
+		case 0:
+		    /* One non-escape: normal input mode.  Save the
+		     * non-escape character as the result. */
+		    retval = *kbinput;
+		    break;
+		case 1:
+		    /* Reset the escape counter. */
+		    escapes = 0;
+		    if (get_key_buffer_len() == 0) {
+			/* One escape followed by a non-escape, and
+			 * there aren't any other keystrokes waiting:
+			 * meta key sequence mode.  Set meta_key to
+			 * TRUE, and save the lowercase version of the
+			 * non-escape character as the result. */
+			*meta_key = TRUE;
+			retval = tolower(*kbinput);
+		    } else
+			/* One escape followed by a non-escape, and
+			 * there are other keystrokes waiting: escape
+			 * sequence mode.  Interpret the escape
+			 * sequence. */
+			retval = parse_escape_seq_kbinput(win,
+				*kbinput);
+		    break;
+		case 2:
+		    if (get_key_buffer_len() == 0) {
+			if (('0' <= *kbinput && *kbinput <= '2' &&
+				byte_digits == 0) || ('0' <= *kbinput &&
+				*kbinput <= '9' && byte_digits > 0)) {
+			    /* Two escapes followed by one or more
+			     * decimal digits, and there aren't any
+			     * other keystrokes waiting: byte sequence
+			     * mode.  If the byte sequence's range is
+			     * limited to 2XX (the first digit is in the
+			     * '0' to '2' range and it's the first
+			     * digit, or it's in the '0' to '9' range
+			     * and it's not the first digit), increment
+			     * the byte sequence counter and interpret
+			     * the digit.  If the byte sequence's range
+			     * is not limited to 2XX, fall through. */
+			    int byte;
+
+			    byte_digits++;
+			    byte = get_byte_kbinput(*kbinput);
+
+			    if (byte != ERR) {
+				char *byte_mb;
+				int byte_mb_len, *seq, i;
+
+				/* If we've read in a complete byte
+				 * sequence, reset the escape counter
+				 * and the byte sequence counter, and
+				 * put back the corresponding byte
+				 * value. */
+				escapes = 0;
+				byte_digits = 0;
+
+				/* Put back the multibyte equivalent of
+				 * the byte value. */
+				byte_mb = make_mbchar((long)byte,
+					&byte_mb_len);
+
+				seq = (int *)nmalloc(byte_mb_len *
+					sizeof(int));
+
+				for (i = 0; i < byte_mb_len; i++)
+				    seq[i] = (unsigned char)byte_mb[i];
+
+				unget_input(seq, byte_mb_len);
+
+				free(byte_mb);
+				free(seq);
+			    }
+			} else {
+			    /* Reset the escape counter. */
+			    escapes = 0;
+			    if (byte_digits == 0)
+				/* Two escapes followed by a non-decimal
+				 * digit or a decimal digit that would
+				 * create a byte sequence greater than
+				 * 2XX, we're not in the middle of a
+				 * byte sequence, and there aren't any
+				 * other keystrokes waiting: control
+				 * character sequence mode.  Interpret
+				 * the control sequence and save the
+				 * corresponding control character as
+				 * the result. */
+				retval = get_control_kbinput(*kbinput);
+			    else {
+				/* If we're in the middle of a byte
+				 * sequence, reset the byte sequence
+				 * counter and save the character we got
+				 * as the result. */
+				byte_digits = 0;
+				retval = *kbinput;
+			    }
+			}
+		    } else {
+			/* Two escapes followed by a non-escape, and
+			 * there are other keystrokes waiting: combined
+			 * meta and escape sequence mode.  Reset the
+			 * escape counter, set meta_key to TRUE, and
+			 * interpret the escape sequence. */
+			escapes = 0;
+			*meta_key = TRUE;
+			retval = parse_escape_seq_kbinput(win,
+				*kbinput);
+		    }
+		    break;
+		case 3:
+		    /* Reset the escape counter. */
+		    escapes = 0;
+		    if (get_key_buffer_len() == 0)
+			/* Three escapes followed by a non-escape, and
+			 * there aren't any other keystrokes waiting:
+			 * normal input mode.  Save the non-escape
+			 * character as the result. */
+			retval = *kbinput;
+		    else
+			/* Three escapes followed by a non-escape, and
+			 * there are other keystrokes waiting: combined
+			 * control character and escape sequence mode.
+			 * Interpret the escape sequence, and interpret
+			 * the result as a control sequence. */
+			retval = get_control_kbinput(
+				parse_escape_seq_kbinput(win,
+				*kbinput));
+		    break;
+	    }
+    }
+
+    if (retval != ERR) {
+	switch (retval) {
+	    case NANO_CONTROL_8:
+		retval = ISSET(REBIND_DELETE) ? sc_seq_or(do_delete, 0) :
+			sc_seq_or(do_backspace, 0);
+		break;
+	    case KEY_DOWN:
+#ifdef KEY_SDOWN
+	    /* ncurses and Slang don't support KEY_SDOWN. */
+	    case KEY_SDOWN:
+#endif
+		retval = sc_seq_or(do_down_void, *kbinput);
+		break;
+	    case KEY_UP:
+#ifdef KEY_SUP
+	    /* ncurses and Slang don't support KEY_SUP. */
+	    case KEY_SUP:
+#endif
+		retval = sc_seq_or(do_up_void, *kbinput);
+		break;
+	    case KEY_LEFT:
+#ifdef KEY_SLEFT
+	    /* Slang doesn't support KEY_SLEFT. */
+	    case KEY_SLEFT:
+#endif
+		retval = sc_seq_or(do_left, *kbinput);
+		break;
+	    case KEY_RIGHT:
+#ifdef KEY_SRIGHT
+	    /* Slang doesn't support KEY_SRIGHT. */
+	    case KEY_SRIGHT:
+#endif
+		retval = sc_seq_or(do_right, *kbinput);
+		break;
+#ifdef KEY_SHOME
+	    /* HP-UX 10-11 and Slang don't support KEY_SHOME. */
+	    case KEY_SHOME:
+#endif
+	    case KEY_A1:	/* Home (7) on numeric keypad with
+				 * NumLock off. */
+		retval = sc_seq_or(do_home, *kbinput);
+		break;
+	    case KEY_BACKSPACE:
+		retval = sc_seq_or(do_backspace, *kbinput);
+		break;
+#ifdef KEY_SDC
+	    /* Slang doesn't support KEY_SDC. */
+	    case KEY_SDC:
+		if (ISSET(REBIND_DELETE))
+		   retval = sc_seq_or(do_delete, *kbinput);
+		else
+		   retval = sc_seq_or(do_backspace, *kbinput);
+		break;
+#endif
+#ifdef KEY_SIC
+	    /* Slang doesn't support KEY_SIC. */
+	    case KEY_SIC:
+		retval = sc_seq_or(do_insertfile_void, *kbinput);
+		break;
+#endif
+	    case KEY_C3:	/* PageDown (4) on numeric keypad with
+				 * NumLock off. */
+		retval = sc_seq_or(do_page_down, *kbinput);
+		break;
+	    case KEY_A3:	/* PageUp (9) on numeric keypad with
+				 * NumLock off. */
+		retval = sc_seq_or(do_page_up, *kbinput);
+		break;
+	    case KEY_ENTER:
+		retval = sc_seq_or(do_enter_void, *kbinput);
+		break;
+	    case KEY_B2:	/* Center (5) on numeric keypad with
+				 * NumLock off. */
+		retval = ERR;
+		break;
+	    case KEY_C1:	/* End (1) on numeric keypad with
+				 * NumLock off. */
+#ifdef KEY_SEND
+	    /* HP-UX 10-11 and Slang don't support KEY_SEND. */
+	    case KEY_SEND:
+#endif
+		retval = sc_seq_or(do_end, *kbinput);
+		break;
+#ifdef KEY_BEG
+	    /* Slang doesn't support KEY_BEG. */
+	    case KEY_BEG:	/* Center (5) on numeric keypad with
+				 * NumLock off. */
+		retval = ERR;
+		break;
+#endif
+#ifdef KEY_CANCEL
+	    /* Slang doesn't support KEY_CANCEL. */
+	    case KEY_CANCEL:
+#ifdef KEY_SCANCEL
+	    /* Slang doesn't support KEY_SCANCEL. */
+	    case KEY_SCANCEL:
+#endif
+		retval = first_sc_for(currmenu, do_cancel)->seq;
+		break;
+#endif
+#ifdef KEY_SBEG
+	    /* Slang doesn't support KEY_SBEG. */
+	    case KEY_SBEG:	/* Center (5) on numeric keypad with
+				 * NumLock off. */
+		retval = ERR;
+		break;
+#endif
+#ifdef KEY_SSUSPEND
+	    /* Slang doesn't support KEY_SSUSPEND. */
+	    case KEY_SSUSPEND:
+		retval = sc_seq_or(do_suspend_void, 0);
+		break;
+#endif
+#ifdef KEY_SUSPEND
+	    /* Slang doesn't support KEY_SUSPEND. */
+	    case KEY_SUSPEND:
+		retval =  sc_seq_or(do_suspend_void, 0);
+		break;
+#endif
+#ifdef PDCURSES
+	    case KEY_SHIFT_L:
+	    case KEY_SHIFT_R:
+	    case KEY_CONTROL_L:
+	    case KEY_CONTROL_R:
+	    case KEY_ALT_L:
+	    case KEY_ALT_R:
+		retval = ERR;
+		break;
+#endif
+#if !defined(NANO_TINY) && defined(KEY_RESIZE)
+	    /* Since we don't change the default SIGWINCH handler when
+	     * NANO_TINY is defined, KEY_RESIZE is never generated.
+	     * Also, Slang and SunOS 5.7-5.9 don't support
+	     * KEY_RESIZE. */
+	    case KEY_RESIZE:
+		retval = ERR;
+		break;
+#endif
+	}
+
+	/* If our result is an extended keypad value (i.e. a value
+	 * outside of byte range), set func_key to TRUE. */
+	if (retval != ERR)
+	    *func_key = !is_byte(retval);
+    }
+
+#ifdef DEBUG
+    fprintf(stderr, "parse_kbinput(): kbinput = %d, meta_key = %s, func_key = %s, escapes = %d, byte_digits = %d, retval = %d\n", *kbinput, *meta_key ? "TRUE" : "FALSE", *func_key ? "TRUE" : "FALSE", escapes, byte_digits, retval);
+#endif
+
+    free(kbinput);
+
+    /* Return the result. */
+    return retval;
+}
+
+/* Translate escape sequences, most of which correspond to extended
+ * keypad values, into their corresponding key values.  These sequences
+ * are generated when the keypad doesn't support the needed keys.
+ * Assume that Escape has already been read in. */
+int get_escape_seq_kbinput(const int *seq, size_t seq_len)
+{
+    int retval = ERR;
+
+    if (seq_len > 1) {
+	switch (seq[0]) {
+	    case 'O':
+		switch (seq[1]) {
+		    case '1':
+			if (seq_len >= 3) {
+			    switch (seq[2]) {
+				case ';':
+    if (seq_len >= 4) {
+	switch (seq[3]) {
+	    case '2':
+		if (seq_len >= 5) {
+		    switch (seq[4]) {
+			case 'A': /* Esc O 1 ; 2 A == Shift-Up on
+				   * Terminal. */
+			case 'B': /* Esc O 1 ; 2 B == Shift-Down on
+				   * Terminal. */
+			case 'C': /* Esc O 1 ; 2 C == Shift-Right on
+				   * Terminal. */
+			case 'D': /* Esc O 1 ; 2 D == Shift-Left on
+				   * Terminal. */
+			    retval = get_escape_seq_abcd(seq[4]);
+			    break;
+			case 'P': /* Esc O 1 ; 2 P == F13 on
+				   * Terminal. */
+			    retval = KEY_F(13);
+			    break;
+			case 'Q': /* Esc O 1 ; 2 Q == F14 on
+				   * Terminal. */
+			    retval = KEY_F(14);
+			    break;
+			case 'R': /* Esc O 1 ; 2 R == F15 on
+				   * Terminal. */
+			    retval = KEY_F(15);
+			    break;
+			case 'S': /* Esc O 1 ; 2 S == F16 on
+				   * Terminal. */
+			    retval = KEY_F(16);
+			    break;
+		    }
+		}
+		break;
+	    case '5':
+		if (seq_len >= 5) {
+		    switch (seq[4]) {
+			case 'A': /* Esc O 1 ; 5 A == Ctrl-Up on
+				   * Terminal. */
+			case 'B': /* Esc O 1 ; 5 B == Ctrl-Down on
+				   * Terminal. */
+			case 'C': /* Esc O 1 ; 5 C == Ctrl-Right on
+				   * Terminal. */
+			case 'D': /* Esc O 1 ; 5 D == Ctrl-Left on
+				   * Terminal. */
+			    retval = get_escape_seq_abcd(seq[4]);
+			    break;
+		    }
+		}
+		break;
+	}
+    }
+				    break;
+			    }
+			}
+			break;
+		    case '2':
+			if (seq_len >= 3) {
+			    switch (seq[2]) {
+				case 'P': /* Esc O 2 P == F13 on
+					   * xterm. */
+				    retval = KEY_F(13);
+				    break;
+				case 'Q': /* Esc O 2 Q == F14 on
+					   * xterm. */
+				    retval = KEY_F(14);
+				    break;
+				case 'R': /* Esc O 2 R == F15 on
+					   * xterm. */
+				    retval = KEY_F(15);
+				    break;
+				case 'S': /* Esc O 2 S == F16 on
+					   * xterm. */
+				    retval = KEY_F(16);
+				    break;
+			    }
+			}
+			break;
+		    case 'A': /* Esc O A == Up on VT100/VT320/xterm. */
+		    case 'B': /* Esc O B == Down on
+			       * VT100/VT320/xterm. */
+		    case 'C': /* Esc O C == Right on
+			       * VT100/VT320/xterm. */
+		    case 'D': /* Esc O D == Left on
+			       * VT100/VT320/xterm. */
+			retval = get_escape_seq_abcd(seq[1]);
+			break;
+		    case 'E': /* Esc O E == Center (5) on numeric keypad
+			       * with NumLock off on xterm. */
+			retval = KEY_B2;
+			break;
+		    case 'F': /* Esc O F == End on xterm/Terminal. */
+			retval = sc_seq_or(do_end, 0);
+			break;
+		    case 'H': /* Esc O H == Home on xterm/Terminal. */
+			retval = sc_seq_or(do_home, 0);;
+			break;
+		    case 'M': /* Esc O M == Enter on numeric keypad with
+			       * NumLock off on VT100/VT220/VT320/xterm/
+			       * rxvt/Eterm. */
+			retval = sc_seq_or(do_home, 0);;
+			break;
+		    case 'P': /* Esc O P == F1 on VT100/VT220/VT320/Mach
+			       * console. */
+			retval = KEY_F(1);
+			break;
+		    case 'Q': /* Esc O Q == F2 on VT100/VT220/VT320/Mach
+			       * console. */
+			retval = KEY_F(2);
+			break;
+		    case 'R': /* Esc O R == F3 on VT100/VT220/VT320/Mach
+			       * console. */
+			retval = KEY_F(3);
+			break;
+		    case 'S': /* Esc O S == F4 on VT100/VT220/VT320/Mach
+			       * console. */
+			retval = KEY_F(4);
+			break;
+		    case 'T': /* Esc O T == F5 on Mach console. */
+			retval = KEY_F(5);
+			break;
+		    case 'U': /* Esc O U == F6 on Mach console. */
+			retval = KEY_F(6);
+			break;
+		    case 'V': /* Esc O V == F7 on Mach console. */
+			retval = KEY_F(7);
+			break;
+		    case 'W': /* Esc O W == F8 on Mach console. */
+			retval = KEY_F(8);
+			break;
+		    case 'X': /* Esc O X == F9 on Mach console. */
+			retval = KEY_F(9);
+			break;
+		    case 'Y': /* Esc O Y == F10 on Mach console. */
+			retval = KEY_F(10);
+			break;
+		    case 'a': /* Esc O a == Ctrl-Up on rxvt. */
+		    case 'b': /* Esc O b == Ctrl-Down on rxvt. */
+		    case 'c': /* Esc O c == Ctrl-Right on rxvt. */
+		    case 'd': /* Esc O d == Ctrl-Left on rxvt. */
+			retval = get_escape_seq_abcd(seq[1]);
+			break;
+		    case 'j': /* Esc O j == '*' on numeric keypad with
+			       * NumLock off on VT100/VT220/VT320/xterm/
+			       * rxvt/Eterm/Terminal. */
+			retval = '*';
+			break;
+		    case 'k': /* Esc O k == '+' on numeric keypad with
+			       * NumLock off on VT100/VT220/VT320/xterm/
+			       * rxvt/Eterm/Terminal. */
+			retval = '+';
+			break;
+		    case 'l': /* Esc O l == ',' on numeric keypad with
+			       * NumLock off on VT100/VT220/VT320/xterm/
+			       * rxvt/Eterm/Terminal. */
+			retval = ',';
+			break;
+		    case 'm': /* Esc O m == '-' on numeric keypad with
+			       * NumLock off on VT100/VT220/VT320/xterm/
+			       * rxvt/Eterm/Terminal. */
+			retval = '-';
+			break;
+		    case 'n': /* Esc O n == Delete (.) on numeric keypad
+			       * with NumLock off on VT100/VT220/VT320/
+			       * xterm/rxvt/Eterm/Terminal. */
+			retval = sc_seq_or(do_delete, 0);;
+			break;
+		    case 'o': /* Esc O o == '/' on numeric keypad with
+			       * NumLock off on VT100/VT220/VT320/xterm/
+			       * rxvt/Eterm/Terminal. */
+			retval = '/';
+			break;
+		    case 'p': /* Esc O p == Insert (0) on numeric keypad
+			       * with NumLock off on VT100/VT220/VT320/
+			       * rxvt/Eterm/Terminal. */
+			retval = sc_seq_or(do_insertfile_void, 0);;
+			break;
+		    case 'q': /* Esc O q == End (1) on numeric keypad
+			       * with NumLock off on VT100/VT220/VT320/
+			       * rxvt/Eterm/Terminal. */
+			retval = sc_seq_or(do_end, 0);;
+			break;
+		    case 'r': /* Esc O r == Down (2) on numeric keypad
+			       * with NumLock off on VT100/VT220/VT320/
+			       * rxvt/Eterm/Terminal. */
+			retval = sc_seq_or(do_down_void, 0);;
+			break;
+		    case 's': /* Esc O s == PageDown (3) on numeric
+			       * keypad with NumLock off on VT100/VT220/
+			       * VT320/rxvt/Eterm/Terminal. */
+			retval = sc_seq_or(do_page_down, 0);;
+			break;
+		    case 't': /* Esc O t == Left (4) on numeric keypad
+			       * with NumLock off on VT100/VT220/VT320/
+			       * rxvt/Eterm/Terminal. */
+			retval = sc_seq_or(do_left, 0);;
+			break;
+		    case 'u': /* Esc O u == Center (5) on numeric keypad
+			       * with NumLock off on VT100/VT220/VT320/
+			       * rxvt/Eterm. */
+			retval = KEY_B2;
+			break;
+		    case 'v': /* Esc O v == Right (6) on numeric keypad
+			       * with NumLock off on VT100/VT220/VT320/
+			       * rxvt/Eterm/Terminal. */
+			retval = sc_seq_or(do_right, 0);
+			break;
+		    case 'w': /* Esc O w == Home (7) on numeric keypad
+			       * with NumLock off on VT100/VT220/VT320/
+			       * rxvt/Eterm/Terminal. */
+			retval = sc_seq_or(do_home, 0);
+			break;
+		    case 'x': /* Esc O x == Up (8) on numeric keypad
+			       * with NumLock off on VT100/VT220/VT320/
+			       * rxvt/Eterm/Terminal. */
+			retval = sc_seq_or(do_up_void, 0);
+			break;
+		    case 'y': /* Esc O y == PageUp (9) on numeric keypad
+			       * with NumLock off on VT100/VT220/VT320/
+			       * rxvt/Eterm/Terminal. */
+			retval = sc_seq_or(do_page_up, 0);
+			break;
+		}
+		break;
+	    case 'o':
+		switch (seq[1]) {
+		    case 'a': /* Esc o a == Ctrl-Up on Eterm. */
+		    case 'b': /* Esc o b == Ctrl-Down on Eterm. */
+		    case 'c': /* Esc o c == Ctrl-Right on Eterm. */
+		    case 'd': /* Esc o d == Ctrl-Left on Eterm. */
+			retval = get_escape_seq_abcd(seq[1]);
+			break;
+		}
+		break;
+	    case '[':
+		switch (seq[1]) {
+		    case '1':
+			if (seq_len >= 3) {
+			    switch (seq[2]) {
+				case '1': /* Esc [ 1 1 ~ == F1 on rxvt/
+					   * Eterm. */
+				    retval = KEY_F(1);
+				    break;
+				case '2': /* Esc [ 1 2 ~ == F2 on rxvt/
+					   * Eterm. */
+				    retval = KEY_F(2);
+				    break;
+				case '3': /* Esc [ 1 3 ~ == F3 on rxvt/
+					   * Eterm. */
+				    retval = KEY_F(3);
+				    break;
+				case '4': /* Esc [ 1 4 ~ == F4 on rxvt/
+					   * Eterm. */
+				    retval = KEY_F(4);
+				    break;
+				case '5': /* Esc [ 1 5 ~ == F5 on xterm/
+					   * rxvt/Eterm. */
+				    retval = KEY_F(5);
+				    break;
+				case '7': /* Esc [ 1 7 ~ == F6 on
+					   * VT220/VT320/Linux console/
+					   * xterm/rxvt/Eterm. */
+				    retval = KEY_F(6);
+				    break;
+				case '8': /* Esc [ 1 8 ~ == F7 on
+					   * VT220/VT320/Linux console/
+					   * xterm/rxvt/Eterm. */
+				    retval = KEY_F(7);
+				    break;
+				case '9': /* Esc [ 1 9 ~ == F8 on
+					   * VT220/VT320/Linux console/
+					   * xterm/rxvt/Eterm. */
+				    retval = KEY_F(8);
+				    break;
+				case ';':
+    if (seq_len >= 4) {
+	switch (seq[3]) {
+	    case '2':
+		if (seq_len >= 5) {
+		    switch (seq[4]) {
+			case 'A': /* Esc [ 1 ; 2 A == Shift-Up on
+				   * xterm. */
+			case 'B': /* Esc [ 1 ; 2 B == Shift-Down on
+				   * xterm. */
+			case 'C': /* Esc [ 1 ; 2 C == Shift-Right on
+				   * xterm. */
+			case 'D': /* Esc [ 1 ; 2 D == Shift-Left on
+				   * xterm. */
+			    retval = get_escape_seq_abcd(seq[4]);
+			    break;
+		    }
+		}
+		break;
+	    case '5':
+		if (seq_len >= 5) {
+		    switch (seq[4]) {
+			case 'A': /* Esc [ 1 ; 5 A == Ctrl-Up on
+				   * xterm. */
+			case 'B': /* Esc [ 1 ; 5 B == Ctrl-Down on
+				   * xterm. */
+			case 'C': /* Esc [ 1 ; 5 C == Ctrl-Right on
+				   * xterm. */
+			case 'D': /* Esc [ 1 ; 5 D == Ctrl-Left on
+				   * xterm. */
+			    retval = get_escape_seq_abcd(seq[4]);
+			    break;
+		    }
+		}
+		break;
+	}
+    }
+				    break;
+				default: /* Esc [ 1 ~ == Home on
+					  * VT320/Linux console. */
+				    retval = sc_seq_or(do_home, 0);;
+				    break;
+			    }
+			}
+			break;
+		    case '2':
+			if (seq_len >= 3) {
+			    switch (seq[2]) {
+				case '0': /* Esc [ 2 0 ~ == F9 on
+					   * VT220/VT320/Linux console/
+					   * xterm/rxvt/Eterm. */
+				    retval = KEY_F(9);
+				    break;
+				case '1': /* Esc [ 2 1 ~ == F10 on
+					   * VT220/VT320/Linux console/
+					   * xterm/rxvt/Eterm. */
+				    retval = KEY_F(10);
+				    break;
+				case '3': /* Esc [ 2 3 ~ == F11 on
+					   * VT220/VT320/Linux console/
+					   * xterm/rxvt/Eterm. */
+				    retval = KEY_F(11);
+				    break;
+				case '4': /* Esc [ 2 4 ~ == F12 on
+					   * VT220/VT320/Linux console/
+					   * xterm/rxvt/Eterm. */
+				    retval = KEY_F(12);
+				    break;
+				case '5': /* Esc [ 2 5 ~ == F13 on
+					   * VT220/VT320/Linux console/
+					   * rxvt/Eterm. */
+				    retval = KEY_F(13);
+				    break;
+				case '6': /* Esc [ 2 6 ~ == F14 on
+					   * VT220/VT320/Linux console/
+					   * rxvt/Eterm. */
+				    retval = KEY_F(14);
+				    break;
+				case '8': /* Esc [ 2 8 ~ == F15 on
+					   * VT220/VT320/Linux console/
+					   * rxvt/Eterm. */
+				    retval = KEY_F(15);
+				    break;
+				case '9': /* Esc [ 2 9 ~ == F16 on
+					   * VT220/VT320/Linux console/
+					   * rxvt/Eterm. */
+				    retval = KEY_F(16);
+				    break;
+				default: /* Esc [ 2 ~ == Insert on
+					  * VT220/VT320/Linux console/
+					  * xterm/Terminal. */
+				    retval = sc_seq_or(do_insertfile_void, 0);;
+				    break;
+			    }
+			}
+			break;
+		    case '3': /* Esc [ 3 ~ == Delete on VT220/VT320/
+			       * Linux console/xterm/Terminal. */
+			retval = sc_seq_or(do_delete, 0);;
+			break;
+		    case '4': /* Esc [ 4 ~ == End on VT220/VT320/Linux
+			       * console/xterm. */
+			retval = sc_seq_or(do_end, 0);;
+			break;
+		    case '5': /* Esc [ 5 ~ == PageUp on VT220/VT320/
+			       * Linux console/xterm/Terminal;
+			       * Esc [ 5 ^ == PageUp on Eterm. */
+			retval = sc_seq_or(do_page_up, 0);;
+			break;
+		    case '6': /* Esc [ 6 ~ == PageDown on VT220/VT320/
+			       * Linux console/xterm/Terminal;
+			        * Esc [ 6 ^ == PageDown on Eterm. */
+			retval = sc_seq_or(do_page_down, 0);;
+			break;
+		    case '7': /* Esc [ 7 ~ == Home on rxvt. */
+			retval = sc_seq_or(do_home, 0);
+			break;
+		    case '8': /* Esc [ 8 ~ == End on rxvt. */
+			retval = sc_seq_or(do_end, 0);
+			break;
+		    case '9': /* Esc [ 9 == Delete on Mach console. */
+			retval = sc_seq_or(do_delete, 0);;
+			break;
+		    case '@': /* Esc [ @ == Insert on Mach console. */
+			retval = sc_seq_or(do_insertfile_void, 0);;
+			break;
+		    case 'A': /* Esc [ A == Up on ANSI/VT220/Linux
+			       * console/FreeBSD console/Mach console/
+			       * rxvt/Eterm/Terminal. */
+		    case 'B': /* Esc [ B == Down on ANSI/VT220/Linux
+			       * console/FreeBSD console/Mach console/
+			       * rxvt/Eterm/Terminal. */
+		    case 'C': /* Esc [ C == Right on ANSI/VT220/Linux
+			       * console/FreeBSD console/Mach console/
+			       * rxvt/Eterm/Terminal. */
+		    case 'D': /* Esc [ D == Left on ANSI/VT220/Linux
+			       * console/FreeBSD console/Mach console/
+			       * rxvt/Eterm/Terminal. */
+			retval = get_escape_seq_abcd(seq[1]);
+			break;
+		    case 'E': /* Esc [ E == Center (5) on numeric keypad
+			       * with NumLock off on FreeBSD console/
+			       * Terminal. */
+			retval = KEY_B2;
+			break;
+		    case 'F': /* Esc [ F == End on FreeBSD
+			       * console/Eterm. */
+			retval = sc_seq_or(do_end, 0);
+			break;
+		    case 'G': /* Esc [ G == PageDown on FreeBSD
+			       * console. */
+			retval = sc_seq_or(do_page_down, 0);
+			break;
+		    case 'H': /* Esc [ H == Home on ANSI/VT220/FreeBSD
+			       * console/Mach console/Eterm. */
+			retval = sc_seq_or(do_home, 0);
+			break;
+		    case 'I': /* Esc [ I == PageUp on FreeBSD
+			       * console. */
+			retval = sc_seq_or(do_page_up, 0);
+			break;
+		    case 'L': /* Esc [ L == Insert on ANSI/FreeBSD
+			       * console. */
+			retval = sc_seq_or(do_insertfile_void, 0);
+			break;
+		    case 'M': /* Esc [ M == F1 on FreeBSD console. */
+			retval = KEY_F(1);
+			break;
+		    case 'N': /* Esc [ N == F2 on FreeBSD console. */
+			retval = KEY_F(2);
+			break;
+		    case 'O':
+			if (seq_len >= 3) {
+			    switch (seq[2]) {
+				case 'P': /* Esc [ O P == F1 on
+					   * xterm. */
+				    retval = KEY_F(1);
+				    break;
+				case 'Q': /* Esc [ O Q == F2 on
+					   * xterm. */
+				    retval = KEY_F(2);
+				    break;
+				case 'R': /* Esc [ O R == F3 on
+					   * xterm. */
+				    retval = KEY_F(3);
+				    break;
+				case 'S': /* Esc [ O S == F4 on
+					   * xterm. */
+				    retval = KEY_F(4);
+				    break;
+			    }
+			} else
+			    /* Esc [ O == F3 on FreeBSD console. */
+			    retval = KEY_F(3);
+			break;
+		    case 'P': /* Esc [ P == F4 on FreeBSD console. */
+			retval = KEY_F(4);
+			break;
+		    case 'Q': /* Esc [ Q == F5 on FreeBSD console. */
+			retval = KEY_F(5);
+			break;
+		    case 'R': /* Esc [ R == F6 on FreeBSD console. */
+			retval = KEY_F(6);
+			break;
+		    case 'S': /* Esc [ S == F7 on FreeBSD console. */
+			retval = KEY_F(7);
+			break;
+		    case 'T': /* Esc [ T == F8 on FreeBSD console. */
+			retval = KEY_F(8);
+			break;
+		    case 'U': /* Esc [ U == PageDown on Mach console. */
+			retval = sc_seq_or(do_page_down, 0);
+			break;
+		    case 'V': /* Esc [ V == PageUp on Mach console. */
+			retval = sc_seq_or(do_page_up, 0);
+			break;
+		    case 'W': /* Esc [ W == F11 on FreeBSD console. */
+			retval = KEY_F(11);
+			break;
+		    case 'X': /* Esc [ X == F12 on FreeBSD console. */
+			retval = KEY_F(12);
+			break;
+		    case 'Y': /* Esc [ Y == End on Mach console. */
+			retval = sc_seq_or(do_end, 0);
+			break;
+		    case 'Z': /* Esc [ Z == F14 on FreeBSD console. */
+			retval = KEY_F(14);
+			break;
+		    case 'a': /* Esc [ a == Shift-Up on rxvt/Eterm. */
+		    case 'b': /* Esc [ b == Shift-Down on rxvt/Eterm. */
+		    case 'c': /* Esc [ c == Shift-Right on rxvt/
+			       * Eterm. */
+		    case 'd': /* Esc [ d == Shift-Left on rxvt/Eterm. */
+			retval = get_escape_seq_abcd(seq[1]);
+			break;
+		    case '[':
+			if (seq_len >= 3) {
+			    switch (seq[2]) {
+				case 'A': /* Esc [ [ A == F1 on Linux
+					   * console. */
+				    retval = KEY_F(1);
+				    break;
+				case 'B': /* Esc [ [ B == F2 on Linux
+					   * console. */
+				    retval = KEY_F(2);
+				    break;
+				case 'C': /* Esc [ [ C == F3 on Linux
+					   * console. */
+				    retval = KEY_F(3);
+				    break;
+				case 'D': /* Esc [ [ D == F4 on Linux
+					   * console. */
+				    retval = KEY_F(4);
+				    break;
+				case 'E': /* Esc [ [ E == F5 on Linux
+					   * console. */
+				    retval = KEY_F(5);
+				    break;
+			    }
+			}
+			break;
+		}
+		break;
+	}
+    }
+
+#ifdef DEBUG
+    fprintf(stderr, "get_escape_seq_kbinput(): retval = %d\n", retval);
+#endif
+
+    return retval;
+}
+
+/* Return the equivalent arrow key value for the case-insensitive
+ * letters A (up), B (down), C (right), and D (left).  These are common
+ * to many escape sequences. */
+int get_escape_seq_abcd(int kbinput)
+{
+    switch (tolower(kbinput)) {
+	case 'a':
+	    return sc_seq_or(do_up_void, 0);;
+	case 'b':
+	    return sc_seq_or(do_down_void, 0);;
+	case 'c':
+	    return sc_seq_or(do_right, 0);;
+	case 'd':
+	    return sc_seq_or(do_left, 0);;
+	default:
+	    return ERR;
+    }
+}
+
+/* Interpret the escape sequence in the keystroke buffer, the first
+ * character of which is kbinput.  Assume that the keystroke buffer
+ * isn't empty, and that the initial escape has already been read in. */
+int parse_escape_seq_kbinput(WINDOW *win, int kbinput)
+{
+    int retval, *seq;
+    size_t seq_len;
+
+    /* Put back the non-escape character, get the complete escape
+     * sequence, translate the sequence into its corresponding key
+     * value, and save that as the result. */
+    unget_input(&kbinput, 1);
+    seq_len = get_key_buffer_len();
+    seq = get_input(NULL, seq_len);
+    retval = get_escape_seq_kbinput(seq, seq_len);
+
+    free(seq);
+
+    /* If we got an unrecognized escape sequence, throw it out. */
+    if (retval == ERR) {
+	if (win == edit) {
+	    statusbar(_("Unknown Command"));
+	    beep();
+	}
+    }
+
+#ifdef DEBUG
+    fprintf(stderr, "parse_escape_seq_kbinput(): kbinput = %d, seq_len = %lu, retval = %d\n", kbinput, (unsigned long)seq_len, retval);
+#endif
+
+    return retval;
+}
+
+/* Translate a byte sequence: turn a three-digit decimal number (from
+ * 000 to 255) into its corresponding byte value. */
+int get_byte_kbinput(int kbinput)
+{
+    static int byte_digits = 0, byte = 0;
+    int retval = ERR;
+
+    /* Increment the byte digit counter. */
+    byte_digits++;
+
+    switch (byte_digits) {
+	case 1:
+	    /* First digit: This must be from zero to two.  Put it in
+	     * the 100's position of the byte sequence holder. */
+	    if ('0' <= kbinput && kbinput <= '2')
+		byte = (kbinput - '0') * 100;
+	    else
+		/* This isn't the start of a byte sequence.  Return this
+		 * character as the result. */
+		retval = kbinput;
+	    break;
+	case 2:
+	    /* Second digit: This must be from zero to five if the first
+	     * was two, and may be any decimal value if the first was
+	     * zero or one.  Put it in the 10's position of the byte
+	     * sequence holder. */
+	    if (('0' <= kbinput && kbinput <= '5') || (byte < 200 &&
+		'6' <= kbinput && kbinput <= '9'))
+		byte += (kbinput - '0') * 10;
+	    else
+		/* This isn't the second digit of a byte sequence.
+		 * Return this character as the result. */
+		retval = kbinput;
+	    break;
+	case 3:
+	    /* Third digit: This must be from zero to five if the first
+	     * was two and the second was between zero and five, and may
+	     * be any decimal value if the first was zero or one and the
+	     * second was between six and nine.  Put it in the 1's
+	     * position of the byte sequence holder. */
+	    if (('0' <= kbinput && kbinput <= '5') || (byte < 250 &&
+		'6' <= kbinput && kbinput <= '9')) {
+		byte += kbinput - '0';
+		/* If this character is a valid decimal value, then the
+		 * byte sequence is complete. */
+		retval = byte;
+	    } else
+		/* This isn't the third digit of a byte sequence.
+		 * Return this character as the result. */
+		retval = kbinput;
+	    break;
+	default:
+	    /* If there are more than three digits, return this
+	     * character as the result.  (Maybe we should produce an
+	     * error instead?) */
+	    retval = kbinput;
+	    break;
+    }
+
+    /* If we have a result, reset the byte digit counter and the byte
+     * sequence holder. */
+    if (retval != ERR) {
+	byte_digits = 0;
+	byte = 0;
+    }
+
+#ifdef DEBUG
+    fprintf(stderr, "get_byte_kbinput(): kbinput = %d, byte_digits = %d, byte = %d, retval = %d\n", kbinput, byte_digits, byte, retval);
+#endif
+
+    return retval;
+}
+
+#ifdef ENABLE_UTF8
+/* If the character in kbinput is a valid hexadecimal digit, multiply it
+ * by factor and add the result to uni. */
+long add_unicode_digit(int kbinput, long factor, long *uni)
+{
+    long retval = ERR;
+
+    if ('0' <= kbinput && kbinput <= '9')
+	*uni += (kbinput - '0') * factor;
+    else if ('a' <= tolower(kbinput) && tolower(kbinput) <= 'f')
+	*uni += (tolower(kbinput) - 'a' + 10) * factor;
+    else
+	/* If this character isn't a valid hexadecimal value, save it as
+	 * the result. */
+	retval = kbinput;
+
+    return retval;
+}
+
+/* Translate a Unicode sequence: turn a six-digit hexadecimal number
+ * (from 000000 to 10FFFF, case-insensitive) into its corresponding
+ * multibyte value. */
+long get_unicode_kbinput(int kbinput)
+{
+    static int uni_digits = 0;
+    static long uni = 0;
+    long retval = ERR;
+
+    /* Increment the Unicode digit counter. */
+    uni_digits++;
+
+    switch (uni_digits) {
+	case 1:
+	    /* First digit: This must be zero or one.  Put it in the
+	     * 0x100000's position of the Unicode sequence holder. */
+	    if ('0' <= kbinput && kbinput <= '1')
+		uni = (kbinput - '0') * 0x100000;
+	    else
+		/* This isn't the first digit of a Unicode sequence.
+		 * Return this character as the result. */
+		retval = kbinput;
+	    break;
+	case 2:
+	    /* Second digit: This must be zero if the first was one, and
+	     * may be any hexadecimal value if the first was zero.  Put
+	     * it in the 0x10000's position of the Unicode sequence
+	     * holder. */
+	    if (uni == 0 || '0' == kbinput)
+		retval = add_unicode_digit(kbinput, 0x10000, &uni);
+	    else
+		/* This isn't the second digit of a Unicode sequence.
+		 * Return this character as the result. */
+		retval = kbinput;
+	    break;
+	case 3:
+	    /* Third digit: This may be any hexadecimal value.  Put it
+	     * in the 0x1000's position of the Unicode sequence
+	     * holder. */
+	    retval = add_unicode_digit(kbinput, 0x1000, &uni);
+	    break;
+	case 4:
+	    /* Fourth digit: This may be any hexadecimal value.  Put it
+	     * in the 0x100's position of the Unicode sequence
+	     * holder. */
+	    retval = add_unicode_digit(kbinput, 0x100, &uni);
+	    break;
+	case 5:
+	    /* Fifth digit: This may be any hexadecimal value.  Put it
+	     * in the 0x10's position of the Unicode sequence holder. */
+	    retval = add_unicode_digit(kbinput, 0x10, &uni);
+	    break;
+	case 6:
+	    /* Sixth digit: This may be any hexadecimal value.  Put it
+	     * in the 0x1's position of the Unicode sequence holder. */
+	    retval = add_unicode_digit(kbinput, 0x1, &uni);
+	    /* If this character is a valid hexadecimal value, then the
+	     * Unicode sequence is complete. */
+	    if (retval == ERR)
+		retval = uni;
+	    break;
+	default:
+	    /* If there are more than six digits, return this character
+	     * as the result.  (Maybe we should produce an error
+	     * instead?) */
+	    retval = kbinput;
+	    break;
+    }
+
+    /* If we have a result, reset the Unicode digit counter and the
+     * Unicode sequence holder. */
+    if (retval != ERR) {
+	uni_digits = 0;
+	uni = 0;
+    }
+
+#ifdef DEBUG
+    fprintf(stderr, "get_unicode_kbinput(): kbinput = %d, uni_digits = %d, uni = %ld, retval = %ld\n", kbinput, uni_digits, uni, retval);
+#endif
+
+    return retval;
+}
+#endif /* ENABLE_UTF8 */
+
+/* Translate a control character sequence: turn an ASCII non-control
+ * character into its corresponding control character. */
+int get_control_kbinput(int kbinput)
+{
+    int retval;
+
+     /* Ctrl-Space (Ctrl-2, Ctrl-@, Ctrl-`) */
+    if (kbinput == ' ' || kbinput == '2')
+	retval = NANO_CONTROL_SPACE;
+    /* Ctrl-/ (Ctrl-7, Ctrl-_) */
+    else if (kbinput == '/')
+	retval = NANO_CONTROL_7;
+    /* Ctrl-3 (Ctrl-[, Esc) to Ctrl-7 (Ctrl-/, Ctrl-_) */
+    else if ('3' <= kbinput && kbinput <= '7')
+	retval = kbinput - 24;
+    /* Ctrl-8 (Ctrl-?) */
+    else if (kbinput == '8' || kbinput == '?')
+	retval = NANO_CONTROL_8;
+    /* Ctrl-@ (Ctrl-Space, Ctrl-2, Ctrl-`) to Ctrl-_ (Ctrl-/, Ctrl-7) */
+    else if ('@' <= kbinput && kbinput <= '_')
+	retval = kbinput - '@';
+    /* Ctrl-` (Ctrl-2, Ctrl-Space, Ctrl-@) to Ctrl-~ (Ctrl-6, Ctrl-^) */
+    else if ('`' <= kbinput && kbinput <= '~')
+	retval = kbinput - '`';
+    else
+	retval = kbinput;
+
+#ifdef DEBUG
+    fprintf(stderr, "get_control_kbinput(): kbinput = %d, retval = %d\n", kbinput, retval);
+#endif
+
+    return retval;
+}
+
+/* Put the output-formatted characters in output back into the keystroke
+ * buffer, so that they can be parsed and displayed as output again. */
+void unparse_kbinput(char *output, size_t output_len)
+{
+    int *input;
+    size_t i;
+
+    if (output_len == 0)
+	return;
+
+    input = (int *)nmalloc(output_len * sizeof(int));
+
+    for (i = 0; i < output_len; i++)
+	input[i] = (int)output[i];
+
+    unget_input(input, output_len);
+
+    free(input);
+}
+
+/* Read in a stream of characters verbatim, and return the length of the
+ * string in kbinput_len.  Assume nodelay(win) is FALSE. */
+int *get_verbatim_kbinput(WINDOW *win, size_t *kbinput_len)
+{
+    int *retval;
+
+    /* Turn off flow control characters if necessary so that we can type
+     * them in verbatim, and turn the keypad off if necessary so that we
+     * don't get extended keypad values. */
+    if (ISSET(PRESERVE))
+	disable_flow_control();
+    if (!ISSET(REBIND_KEYPAD))
+	keypad(win, FALSE);
+
+    /* Read in a stream of characters and interpret it if possible. */
+    retval = parse_verbatim_kbinput(win, kbinput_len);
+
+    /* Turn flow control characters back on if necessary and turn the
+     * keypad back on if necessary now that we're done. */
+    if (ISSET(PRESERVE))
+	enable_flow_control();
+    if (!ISSET(REBIND_KEYPAD))
+	keypad(win, TRUE);
+
+    return retval;
+}
+
+/* Read in a stream of all available characters, and return the length
+ * of the string in kbinput_len.  Translate the first few characters of
+ * the input into the corresponding multibyte value if possible.  After
+ * that, leave the input as-is. */
+int *parse_verbatim_kbinput(WINDOW *win, size_t *kbinput_len)
+{
+    int *kbinput, *retval;
+
+    /* Read in the first keystroke. */
+    while ((kbinput = get_input(win, 1)) == NULL);
+
+#ifdef ENABLE_UTF8
+    if (using_utf8()) {
+	/* Check whether the first keystroke is a valid hexadecimal
+	 * digit. */
+	long uni = get_unicode_kbinput(*kbinput);
+
+	/* If the first keystroke isn't a valid hexadecimal digit, put
+	 * back the first keystroke. */
+	if (uni != ERR)
+	    unget_input(kbinput, 1);
+
+	/* Otherwise, read in keystrokes until we have a complete
+	 * Unicode sequence, and put back the corresponding Unicode
+	 * value. */
+	else {
+	    char *uni_mb;
+	    int uni_mb_len, *seq, i;
+
+	    if (win == edit)
+		/* TRANSLATORS: This is displayed during the input of a
+		 * six-digit hexadecimal Unicode character code. */
+		statusbar(_("Unicode Input"));
+
+	    while (uni == ERR) {
+		while ((kbinput = get_input(win, 1)) == NULL);
+
+		uni = get_unicode_kbinput(*kbinput);
+	    }
+
+	    /* Put back the multibyte equivalent of the Unicode
+	     * value. */
+	    uni_mb = make_mbchar(uni, &uni_mb_len);
+
+	    seq = (int *)nmalloc(uni_mb_len * sizeof(int));
+
+	    for (i = 0; i < uni_mb_len; i++)
+		seq[i] = (unsigned char)uni_mb[i];
+
+	    unget_input(seq, uni_mb_len);
+
+	    free(seq);
+	    free(uni_mb);
+	}
+    } else
+#endif /* ENABLE_UTF8 */
+
+	/* Put back the first keystroke. */
+	unget_input(kbinput, 1);
+
+    free(kbinput);
+
+    /* Get the complete sequence, and save the characters in it as the
+     * result. */
+    *kbinput_len = get_key_buffer_len();
+    retval = get_input(NULL, *kbinput_len);
+
+    return retval;
+}
+
+#ifndef DISABLE_MOUSE
+/* Handle any mouse event that may have occurred.  We currently handle
+ * releases/clicks of the first mouse button.  If allow_shortcuts is
+ * TRUE, releasing/clicking on a visible shortcut will put back the
+ * keystroke associated with that shortcut.  If NCURSES_MOUSE_VERSION is
+ * at least 2, we also currently handle presses of the fourth mouse
+ * button (upward rolls of the mouse wheel) by putting back the
+ * keystrokes to move up, and presses of the fifth mouse button
+ * (downward rolls of the mouse wheel) by putting back the keystrokes to
+ * move down.  We also store the coordinates of a mouse event that needs
+ * to be handled in mouse_x and mouse_y, relative to the entire screen.
+ * Return -1 on error, 0 if the mouse event needs to be handled, 1 if
+ * it's been handled by putting back keystrokes that need to be handled.
+ * or 2 if it's been ignored.  Assume that KEY_MOUSE has already been
+ * read in. */
+int get_mouseinput(int *mouse_x, int *mouse_y, bool allow_shortcuts)
+{
+    MEVENT mevent;
+    bool in_bottomwin;
+    subnfunc *f;
+
+    *mouse_x = -1;
+    *mouse_y = -1;
+
+    /* First, get the actual mouse event. */
+    if (getmouse(&mevent) == ERR)
+	return -1;
+
+    /* Save the screen coordinates where the mouse event took place. */
+    *mouse_x = mevent.x;
+    *mouse_y = mevent.y;
+
+    in_bottomwin = wenclose(bottomwin, *mouse_y, *mouse_x);
+
+    /* Handle releases/clicks of the first mouse button. */
+    if (mevent.bstate & (BUTTON1_RELEASED | BUTTON1_CLICKED)) {
+	/* If we're allowing shortcuts, the current shortcut list is
+	 * being displayed on the last two lines of the screen, and the
+	 * first mouse button was released on/clicked inside it, we need
+	 * to figure out which shortcut was released on/clicked and put
+	 * back the equivalent keystroke(s) for it. */
+	if (allow_shortcuts && !ISSET(NO_HELP) && in_bottomwin) {
+	    int i;
+		/* The width of all the shortcuts, except for the last
+		 * two, in the shortcut list in bottomwin. */
+	    int j;
+		/* The y-coordinate relative to the beginning of the
+		 * shortcut list in bottomwin. */
+	    size_t currslen;
+		/* The number of shortcuts in the current shortcut
+		 * list. */
+
+	    /* Translate the mouse event coordinates so that they're
+	     * relative to bottomwin. */
+	    wmouse_trafo(bottomwin, mouse_y, mouse_x, FALSE);
+
+	    /* Handle releases/clicks of the first mouse button on the
+	     * statusbar elsewhere. */
+	    if (*mouse_y == 0) {
+		/* Restore the untranslated mouse event coordinates, so
+		 * that they're relative to the entire screen again. */
+		*mouse_x = mevent.x;
+		*mouse_y = mevent.y;
+
+		return 0;
+	    }
+
+	    /* Calculate the y-coordinate relative to the beginning of
+	     * the shortcut list in bottomwin. */
+	    j = *mouse_y - 1;
+
+	    /* Get the shortcut lists' length. */
+	    if (currmenu == MMAIN)
+		currslen = MAIN_VISIBLE;
+	    else {
+		currslen = length_of_list(currmenu);
+
+		/* We don't show any more shortcuts than the main list
+		 * does. */
+		if (currslen > MAIN_VISIBLE)
+		    currslen = MAIN_VISIBLE;
+	    }
+
+	    /* Calculate the width of all of the shortcuts in the list
+	     * except for the last two, which are longer by (COLS % i)
+	     * columns so as to not waste space. */
+	    if (currslen < 2)
+		i = COLS / (MAIN_VISIBLE / 2);
+	    else
+		i = COLS / ((currslen / 2) + (currslen % 2));
+
+	    /* Calculate the x-coordinate relative to the beginning of
+	     * the shortcut list in bottomwin, and add it to j.  j
+	     * should now be the index in the shortcut list of the
+	     * shortcut we released/clicked on. */
+	    j = (*mouse_x / i) * 2 + j;
+
+	    /* Adjust j if we released on the last two shortcuts. */
+	    if ((j >= currslen) && (*mouse_x % i < COLS % i))
+		j -= 2;
+
+	    /* Ignore releases/clicks of the first mouse button beyond
+	     * the last shortcut. */
+	    if (j >= currslen)
+		return 2;
+
+	    /* Go through the shortcut list to determine which shortcut
+	     * we released/clicked on. */
+	    f = allfuncs;
+
+	    for (; j > 0; j--) {
+		if (f->next != NULL)
+		    f = f->next;
+
+                while (f->next != NULL && ((f->menus & currmenu) == 0
+#ifndef DISABLE_HELP
+                       || strlen(f->help) == 0
+#endif
+		))
+		     f = f->next;
+	    }
+
+
+	    /* And put back the equivalent key. */
+	    if (f != NULL) {
+                const sc *s = first_sc_for(currmenu, f->scfunc);
+		if (s != NULL)
+		    unget_kbinput(s->seq, s->type == META, FALSE);
+	    }
+	} else
+	    /* Handle releases/clicks of the first mouse button that
+	     * aren't on the current shortcut list elsewhere. */
+	    return 0;
+    }
+#if NCURSES_MOUSE_VERSION >= 2
+    /* Handle presses of the fourth mouse button (upward rolls of the
+     * mouse wheel) and presses of the fifth mouse button (downward
+     * rolls of the mouse wheel) . */
+    else if (mevent.bstate & (BUTTON4_PRESSED | BUTTON5_PRESSED)) {
+	bool in_edit = wenclose(edit, *mouse_y, *mouse_x);
+
+	if (in_bottomwin)
+	    /* Translate the mouse event coordinates so that they're
+	     * relative to bottomwin. */
+	    wmouse_trafo(bottomwin, mouse_y, mouse_x, FALSE);
+
+	if (in_edit || (in_bottomwin && *mouse_y == 0)) {
+	    int i;
+
+	    /* One upward roll of the mouse wheel is equivalent to
+	     * moving up three lines, and one downward roll of the mouse
+	     * wheel is equivalent to moving down three lines. */
+	    for (i = 0; i < 3; i++)
+		unget_kbinput((mevent.bstate & BUTTON4_PRESSED) ?
+			 sc_seq_or(up_void, 0) : sc_seq_or(DO_DOWN_VOID, 0), FALSE,
+			FALSE);
+
+	    return 1;
+	} else
+	    /* Ignore presses of the fourth mouse button and presses of
+	     * the fifth mouse buttons that aren't on the edit window or
+	     * the statusbar. */
+	    return 2;
+    }
+#endif
+
+    /* Ignore all other mouse events. */
+    return 2;
+}
+#endif /* !DISABLE_MOUSE */
+
+/* Return the shortcut corresponding to the values of kbinput (the key
+ * itself), meta_key (whether the key is a meta sequence), and func_key
+ * (whether the key is a function key), if any.  The shortcut will be
+ * the first one in the list (control key, meta key sequence, function
+ * key, other meta key sequence) for the corresponding function.  For
+ * example, passing in a meta key sequence that corresponds to a
+ * function with a control key, a function key, and a meta key sequence
+ * will return the control key corresponding to that function. */
+const sc *get_shortcut(int menu, int *kbinput, bool
+	*meta_key, bool *func_key)
+{
+    sc *s;
+
+#ifdef DEBUG
+    fprintf(stderr, "get_shortcut(): kbinput = %d, meta_key = %s, func_key = %s\n", *kbinput, *meta_key ? "TRUE" : "FALSE", *func_key ? "TRUE" : "FALSE");
+#endif
+
+    /* Check for shortcuts. */
+    for (s = sclist; s != NULL; s = s->next) {
+        if ((menu & s->menu)
+		&& ((s->type == META && *meta_key == TRUE && *kbinput == s->seq)
+		|| (s->type != META && *kbinput == s->seq))) {
+#ifdef DEBUG
+	    fprintf (stderr, "matched seq \"%s\" and btw meta was %d (menus %d = %d)\n", s->keystr, *meta_key, menu, s->menu);
+#endif
+	    return s;
+	}
+    }
+#ifdef DEBUG
+    fprintf (stderr, "matched nothing btw meta was %d\n", *meta_key);
+#endif
+
+    return NULL;
+}
+
+
+/* Try to get a function back from a window.  Just a wrapper so
+   functions to need to create function_key meta_key blah blah 
+    mmenu - what menu name to look through for valid funcs */
+const subnfunc *getfuncfromkey(WINDOW *win)
+{
+    int kbinput;
+    bool func_key = FALSE, meta_key = FALSE;
+    const sc *s;
+    const subnfunc *f;
+
+    kbinput = parse_kbinput(win, &meta_key, &func_key);
+    if (kbinput == 0)
+	return NULL;
+
+    s = get_shortcut(currmenu, &kbinput, &meta_key, &func_key);
+    if (!s)
+	return NULL;
+
+    f = sctofunc((sc *) s);
+    return f;
+
+}
+
+
+
+/* Move to (x, y) in win, and display a line of n spaces with the
+ * current attributes. */
+void blank_line(WINDOW *win, int y, int x, int n)
+{
+    wmove(win, y, x);
+
+    for (; n > 0; n--)
+	waddch(win, ' ');
+}
+
+/* Blank the first line of the top portion of the window. */
+void blank_titlebar(void)
+{
+    blank_line(topwin, 0, 0, COLS);
+}
+
+/* If the MORE_SPACE flag isn't set, blank the second line of the top
+ * portion of the window. */
+void blank_topbar(void)
+{
+    if (!ISSET(MORE_SPACE))
+	blank_line(topwin, 1, 0, COLS);
+}
+
+/* Blank all the lines of the middle portion of the window, i.e. the
+ * edit window. */
+void blank_edit(void)
+{
+    int i;
+
+    for (i = 0; i < editwinrows; i++)
+	blank_line(edit, i, 0, COLS);
+}
+
+/* Blank the first line of the bottom portion of the window. */
+void blank_statusbar(void)
+{
+    blank_line(bottomwin, 0, 0, COLS);
+}
+
+/* If the NO_HELP flag isn't set, blank the last two lines of the bottom
+ * portion of the window. */
+void blank_bottombars(void)
+{
+    if (!ISSET(NO_HELP)) {
+	blank_line(bottomwin, 1, 0, COLS);
+	blank_line(bottomwin, 2, 0, COLS);
+    }
+}
+
+/* Check if the number of keystrokes needed to blank the statusbar has
+ * been pressed.  If so, blank the statusbar, unless constant cursor
+ * position display is on. */
+void check_statusblank(void)
+{
+    if (statusblank > 0) {
+	statusblank--;
+
+	if (statusblank == 0 && !ISSET(CONST_UPDATE)) {
+	    blank_statusbar();
+	    wnoutrefresh(bottomwin);
+	    reset_cursor();
+	    wnoutrefresh(edit);
+	}
+    }
+}
+
+/* Convert buf into a string that can be displayed on screen.  The
+ * caller wants to display buf starting with column start_col, and
+ * extending for at most len columns.  start_col is zero-based.  len is
+ * one-based, so len == 0 means you get "" returned.  The returned
+ * string is dynamically allocated, and should be freed.  If dollars is
+ * TRUE, the caller might put "$" at the beginning or end of the line if
+ * it's too long. */
+char *display_string(const char *buf, size_t start_col, size_t len, bool
+	dollars)
+{
+    size_t start_index;
+	/* Index in buf of the first character shown. */
+    size_t column;
+	/* Screen column that start_index corresponds to. */
+    size_t alloc_len;
+	/* The length of memory allocated for converted. */
+    char *converted;
+	/* The string we return. */
+    size_t index;
+	/* Current position in converted. */
+    char *buf_mb;
+    int buf_mb_len;
+
+    /* If dollars is TRUE, make room for the "$" at the end of the
+     * line. */
+    if (dollars && len > 0 && strlenpt(buf) > start_col + len)
+	len--;
+
+    if (len == 0)
+	return mallocstrcpy(NULL, "");
+
+    buf_mb = charalloc(mb_cur_max());
+
+    start_index = actual_x(buf, start_col);
+    column = strnlenpt(buf, start_index);
+
+    assert(column <= start_col);
+
+    /* Make sure there's enough room for the initial character, whether
+     * it's a multibyte control character, a non-control multibyte
+     * character, a tab character, or a null terminator.  Rationale:
+     *
+     * multibyte control character followed by a null terminator:
+     *     1 byte ('^') + mb_cur_max() bytes + 1 byte ('\0')
+     * multibyte non-control character followed by a null terminator:
+     *     mb_cur_max() bytes + 1 byte ('\0')
+     * tab character followed by a null terminator:
+     *     mb_cur_max() bytes + (tabsize - 1) bytes + 1 byte ('\0')
+     *
+     * Since tabsize has a minimum value of 1, it can substitute for 1
+     * byte above. */
+    alloc_len = (mb_cur_max() + tabsize + 1) * MAX_BUF_SIZE;
+    converted = charalloc(alloc_len);
+
+    index = 0;
+
+    if (buf[start_index] != '\0' && buf[start_index] != '\t' &&
+	(column < start_col || (dollars && column > 0))) {
+	/* We don't display all of buf[start_index] since it starts to
+	 * the left of the screen. */
+	buf_mb_len = parse_mbchar(buf + start_index, buf_mb, NULL);
+
+	if (is_cntrl_mbchar(buf_mb)) {
+	    if (column < start_col) {
+		char *ctrl_buf_mb = charalloc(mb_cur_max());
+		int ctrl_buf_mb_len, i;
+
+		ctrl_buf_mb = control_mbrep(buf_mb, ctrl_buf_mb,
+			&ctrl_buf_mb_len);
+
+		for (i = 0; i < ctrl_buf_mb_len; i++)
+		    converted[index++] = ctrl_buf_mb[i];
+
+		start_col += mbwidth(ctrl_buf_mb);
+
+		free(ctrl_buf_mb);
+
+		start_index += buf_mb_len;
+	    }
+	}
+#ifdef ENABLE_UTF8
+	else if (using_utf8() && mbwidth(buf_mb) == 2) {
+	    if (column >= start_col) {
+		converted[index++] = ' ';
+		start_col++;
+	    }
+
+	    converted[index++] = ' ';
+	    start_col++;
+
+	    start_index += buf_mb_len;
+	}
+#endif
+    }
+
+    while (buf[start_index] != '\0') {
+	buf_mb_len = parse_mbchar(buf + start_index, buf_mb, NULL);
+
+	/* Make sure there's enough room for the next character, whether
+	 * it's a multibyte control character, a non-control multibyte
+	 * character, a tab character, or a null terminator. */
+	if (index + mb_cur_max() + tabsize + 1 >= alloc_len - 1) {
+	    alloc_len += (mb_cur_max() + tabsize + 1) * MAX_BUF_SIZE;
+	    converted = charealloc(converted, alloc_len);
+	}
+
+	/* If buf contains a tab character, interpret it. */
+	if (*buf_mb == '\t') {
+#if !defined(NANO_TINY) && defined(ENABLE_NANORC)
+	    if (ISSET(WHITESPACE_DISPLAY)) {
+		int i;
+
+		for (i = 0; i < whitespace_len[0]; i++)
+		    converted[index++] = whitespace[i];
+	    } else
+#endif
+		converted[index++] = ' ';
+	    start_col++;
+	    while (start_col % tabsize != 0) {
+		converted[index++] = ' ';
+		start_col++;
+	    }
+	/* If buf contains a control character, interpret it.  If buf
+	 * contains an invalid multibyte control character, display it
+	 * as such.*/
+	} else if (is_cntrl_mbchar(buf_mb)) {
+	    char *ctrl_buf_mb = charalloc(mb_cur_max());
+	    int ctrl_buf_mb_len, i;
+
+	    converted[index++] = '^';
+	    start_col++;
+
+	    ctrl_buf_mb = control_mbrep(buf_mb, ctrl_buf_mb,
+		&ctrl_buf_mb_len);
+
+	    for (i = 0; i < ctrl_buf_mb_len; i++)
+		converted[index++] = ctrl_buf_mb[i];
+
+	    start_col += mbwidth(ctrl_buf_mb);
+
+	    free(ctrl_buf_mb);
+	/* If buf contains a space character, interpret it. */
+	} else if (*buf_mb == ' ') {
+#if !defined(NANO_TINY) && defined(ENABLE_NANORC)
+	    if (ISSET(WHITESPACE_DISPLAY)) {
+		int i;
+
+		for (i = whitespace_len[0]; i < whitespace_len[0] +
+			whitespace_len[1]; i++)
+		    converted[index++] = whitespace[i];
+	    } else
+#endif
+		converted[index++] = ' ';
+	    start_col++;
+	/* If buf contains a non-control character, interpret it.  If
+	 * buf contains an invalid multibyte non-control character,
+	 * display it as such. */
+	} else {
+	    char *nctrl_buf_mb = charalloc(mb_cur_max());
+	    int nctrl_buf_mb_len, i;
+
+	    nctrl_buf_mb = mbrep(buf_mb, nctrl_buf_mb,
+		&nctrl_buf_mb_len);
+
+	    for (i = 0; i < nctrl_buf_mb_len; i++)
+		converted[index++] = nctrl_buf_mb[i];
+
+	    start_col += mbwidth(nctrl_buf_mb);
+
+	    free(nctrl_buf_mb);
+	}
+
+	start_index += buf_mb_len;
+    }
+
+    free(buf_mb);
+
+    assert(alloc_len >= index + 1);
+
+    /* Null-terminate converted. */
+    converted[index] = '\0';
+
+    /* Make sure converted takes up no more than len columns. */
+    index = actual_x(converted, len);
+    null_at(&converted, index);
+
+    return converted;
+}
+
+/* If path is NULL, we're in normal editing mode, so display the current
+ * version of nano, the current filename, and whether the current file
+ * has been modified on the titlebar.  If path isn't NULL, we're in the
+ * file browser, and path contains the directory to start the file
+ * browser in, so display the current version of nano and the contents
+ * of path on the titlebar. */
+void titlebar(const char *path)
+{
+    int space = COLS;
+	/* The space we have available for display. */
+    size_t verlen = strlenpt(PACKAGE_STRING) + 1;
+	/* The length of the version message in columns, plus one for
+	 * padding. */
+    const char *prefix;
+	/* "DIR:", "File:", or "New Buffer".  Goes before filename. */
+    size_t prefixlen;
+	/* The length of the prefix in columns, plus one for padding. */
+    const char *state;
+	/* "Modified", "View", or "".  Shows the state of this
+	 * buffer. */
+    size_t statelen = 0;
+	/* The length of the state in columns, or the length of
+	 * "Modified" if the state is blank and we're not in the file
+	 * browser. */
+    char *exppath = NULL;
+	/* The filename, expanded for display. */
+    bool newfie = FALSE;
+	/* Do we say "New Buffer"? */
+    bool dots = FALSE;
+	/* Do we put an ellipsis before the path? */
+
+    assert(path != NULL || openfile->filename != NULL);
+
+    wattron(topwin, reverse_attr);
+
+    blank_titlebar();
+
+    /* space has to be at least 4: two spaces before the version message,
+     * at least one character of the version message, and one space
+     * after the version message. */
+    if (space < 4)
+	space = 0;
+    else {
+	/* Limit verlen to 1/3 the length of the screen in columns,
+	 * minus three columns for spaces. */
+	if (verlen > (COLS / 3) - 3)
+	    verlen = (COLS / 3) - 3;
+    }
+
+    if (space >= 4) {
+	/* Add a space after the version message, and account for both
+	 * it and the two spaces before it. */
+	mvwaddnstr(topwin, 0, 2, PACKAGE_STRING,
+		actual_x(PACKAGE_STRING, verlen));
+	verlen += 3;
+
+	/* Account for the full length of the version message. */
+	space -= verlen;
+    }
+
+#ifndef DISABLE_BROWSER
+    /* Don't display the state if we're in the file browser. */
+    if (path != NULL)
+	state = "";
+    else
+#endif
+	state = openfile->modified ? _("Modified") : ISSET(VIEW_MODE) ?
+		_("View") : "";
+
+    statelen = strlenpt((*state == '\0' && path == NULL) ?
+	_("Modified") : state);
+
+    /* If possible, add a space before state. */
+    if (space > 0 && statelen < space)
+	statelen++;
+    else
+	goto the_end;
+
+#ifndef DISABLE_BROWSER
+    /* path should be a directory if we're in the file browser. */
+    if (path != NULL)
+	prefix = _("DIR:");
+    else
+#endif
+    if (openfile->filename[0] == '\0') {
+	prefix = _("New Buffer");
+	newfie = TRUE;
+    } else
+	prefix = _("File:");
+
+    prefixlen = strnlenpt(prefix, space - statelen) + 1;
+
+    /* If newfie is FALSE, add a space after prefix. */
+    if (!newfie && prefixlen + statelen < space)
+	prefixlen++;
+
+    /* If we're not in the file browser, set path to the current
+     * filename. */
+    if (path == NULL)
+	path = openfile->filename;
+
+    /* Account for the full lengths of the prefix and the state. */
+    if (space >= prefixlen + statelen)
+	space -= prefixlen + statelen;
+    else
+	space = 0;
+	/* space is now the room we have for the filename. */
+
+    if (!newfie) {
+	size_t lenpt = strlenpt(path), start_col;
+
+	/* Don't set dots to TRUE if we have fewer than eight columns
+	 * (i.e. one column for padding, plus seven columns for a
+	 * filename). */
+	dots = (space >= 8 && lenpt >= space);
+
+	if (dots) {
+	    start_col = lenpt - space + 3;
+	    space -= 3;
+	} else
+	    start_col = 0;
+
+	exppath = display_string(path, start_col, space, FALSE);
+    }
+
+    /* If dots is TRUE, we will display something like "File:
+     * ...ename". */
+    if (dots) {
+	mvwaddnstr(topwin, 0, verlen - 1, prefix, actual_x(prefix,
+		prefixlen));
+	if (space <= -3 || newfie)
+	    goto the_end;
+	waddch(topwin, ' ');
+	waddnstr(topwin, "...", space + 3);
+	if (space <= 0)
+	    goto the_end;
+	waddstr(topwin, exppath);
+    } else {
+	size_t exppathlen = newfie ? 0 : strlenpt(exppath);
+	    /* The length of the expanded filename. */
+
+	/* There is room for the whole filename, so we center it. */
+	mvwaddnstr(topwin, 0, verlen + ((space - exppathlen) / 3),
+		prefix, actual_x(prefix, prefixlen));
+	if (!newfie) {
+	    waddch(topwin, ' ');
+	    waddstr(topwin, exppath);
+	}
+    }
+
+  the_end:
+    free(exppath);
+
+    if (state[0] != '\0') {
+	if (statelen >= COLS - 1)
+	    mvwaddnstr(topwin, 0, 0, state, actual_x(state, COLS));
+	else {
+	    assert(COLS - statelen - 1 >= 0);
+
+	    mvwaddnstr(topwin, 0, COLS - statelen - 1, state,
+		actual_x(state, statelen));
+	}
+    }
+
+    wattroff(topwin, reverse_attr);
+
+    wnoutrefresh(topwin);
+    reset_cursor();
+    wnoutrefresh(edit);
+}
+
+/* Mark the current file as modified if it isn't already, and then
+ * update the titlebar to display the file's new status. */
+void set_modified(void)
+{
+    if (!openfile->modified) {
+	openfile->modified = TRUE;
+	titlebar(NULL);
+    }
+}
+
+/* Display a message on the statusbar, and set disable_cursorpos to
+ * TRUE, so that the message won't be immediately overwritten if
+ * constant cursor position display is on. */
+void statusbar(const char *msg, ...)
+{
+    va_list ap;
+    char *bar, *foo;
+    size_t start_x, foo_len;
+#if !defined(NANO_TINY) && defined(ENABLE_NANORC)
+    bool old_whitespace;
+#endif
+
+    va_start(ap, msg);
+
+    /* Curses mode is turned off.  If we use wmove() now, it will muck
+     * up the terminal settings.  So we just use vfprintf(). */
+    if (isendwin()) {
+	vfprintf(stderr, msg, ap);
+	va_end(ap);
+	return;
+    }
+
+    blank_statusbar();
+
+#if !defined(NANO_TINY) && defined(ENABLE_NANORC)
+    old_whitespace = ISSET(WHITESPACE_DISPLAY);
+    UNSET(WHITESPACE_DISPLAY);
+#endif
+    bar = charalloc(mb_cur_max() * (COLS - 3));
+    vsnprintf(bar, mb_cur_max() * (COLS - 3), msg, ap);
+    va_end(ap);
+    foo = display_string(bar, 0, COLS - 4, FALSE);
+#if !defined(NANO_TINY) && defined(ENABLE_NANORC)
+    if (old_whitespace)
+	SET(WHITESPACE_DISPLAY);
+#endif
+    free(bar);
+    foo_len = strlenpt(foo);
+    start_x = (COLS - foo_len - 4) / 2;
+
+    wmove(bottomwin, 0, start_x);
+    wattron(bottomwin, reverse_attr);
+    waddstr(bottomwin, "[ ");
+    waddstr(bottomwin, foo);
+    free(foo);
+    waddstr(bottomwin, " ]");
+    wattroff(bottomwin, reverse_attr);
+    wnoutrefresh(bottomwin);
+    reset_cursor();
+    wnoutrefresh(edit);
+	/* Leave the cursor at its position in the edit window, not in
+	 * the statusbar. */
+
+    disable_cursorpos = TRUE;
+
+    /* If we're doing quick statusbar blanking, and constant cursor
+     * position display is off, blank the statusbar after only one
+     * keystroke.  Otherwise, blank it after twenty-six keystrokes, as
+     * Pico does. */
+    statusblank =
+#ifndef NANO_TINY
+	ISSET(QUICK_BLANK) && !ISSET(CONST_UPDATE) ? 1 :
+#endif
+	26;
+}
+
+/* Display the shortcut list in s on the last two rows of the bottom
+ * portion of the window. */
+void bottombars(int menu)
+{
+    size_t i, colwidth, slen;
+    subnfunc *f;
+    const sc *s;
+
+    if (ISSET(NO_HELP))
+	return;
+
+    if (menu == MMAIN) {
+	slen = MAIN_VISIBLE;
+
+	assert(slen <= length_of_list(menu));
+    } else {
+	slen = length_of_list(menu);
+
+	/* Don't show any more shortcuts than the main list does. */
+	if (slen > MAIN_VISIBLE)
+	    slen = MAIN_VISIBLE;
+    }
+
+    /* There will be this many characters per column, except for the
+     * last two, which will be longer by (COLS % colwidth) columns so as
+     * to not waste space.  We need at least three columns to display
+     * anything properly. */
+    colwidth = COLS / ((slen / 2) + (slen % 2));
+
+    blank_bottombars();
+
+#ifdef DEBUG
+    fprintf(stderr, "In bottombars, and slen == \"%d\"\n", (int) slen);
+#endif
+
+    for (f = allfuncs, i = 0; i < slen && f != NULL; f = f->next) {
+
+#ifdef DEBUG
+        fprintf(stderr, "Checking menu items....");
+#endif
+        if ((f->menus & menu) == 0)
+	    continue;
+
+        if (!f->desc || strlen(f->desc) == 0)
+	    continue;
+
+#ifdef DEBUG
+        fprintf(stderr, "found one! f->menus = %d, desc = \"%s\"\n", f->menus, f->desc);
+#endif
+        s = first_sc_for(menu, f->scfunc);
+        if (s == NULL) {
+#ifdef DEBUG
+	    fprintf(stderr, "Whoops, guess not, no shortcut key found for func!\n");
+#endif
+            continue;
+        }
+	wmove(bottomwin, 1 + i % 2, (i / 2) * colwidth);
+#ifdef DEBUG
+        fprintf(stderr, "Calling onekey with keystr \"%s\" and desc \"%s\"\n", s->keystr, f->desc);
+#endif
+	onekey(s->keystr, _(f->desc), colwidth + (COLS % colwidth));
+        i++;
+    }
+
+    wnoutrefresh(bottomwin);
+    reset_cursor();
+    wnoutrefresh(edit);
+}
+
+/* Write a shortcut key to the help area at the bottom of the window.
+ * keystroke is e.g. "^G" and desc is e.g. "Get Help".  We are careful
+ * to write at most len characters, even if len is very small and
+ * keystroke and desc are long.  Note that waddnstr(,,(size_t)-1) adds
+ * the whole string!  We do not bother padding the entry with blanks. */
+void onekey(const char *keystroke, const char *desc, size_t len)
+{
+    size_t keystroke_len = strlenpt(keystroke) + 1;
+
+    assert(keystroke != NULL && desc != NULL);
+
+    wattron(bottomwin, reverse_attr);
+    waddnstr(bottomwin, keystroke, actual_x(keystroke, len));
+    wattroff(bottomwin, reverse_attr);
+
+    if (len > keystroke_len)
+	len -= keystroke_len;
+    else
+	len = 0;
+
+    if (len > 0) {
+	waddch(bottomwin, ' ');
+	waddnstr(bottomwin, desc, actual_x(desc, len));
+    }
+}
+
+/* Reset current_y, based on the position of current, and put the cursor
+ * in the edit window at (current_y, current_x). */
+void reset_cursor(void)
+{
+    size_t xpt;
+    /* If we haven't opened any files yet, put the cursor in the top
+     * left corner of the edit window and get out. */
+    if (openfile == NULL) {
+	wmove(edit, 0, 0);
+	return;
+    }
+
+    xpt = xplustabs();
+
+    if (ISSET(SOFTWRAP)) {
+	filestruct *tmp;
+	openfile->current_y = 0;
+
+	for (tmp = openfile->edittop; tmp && tmp != openfile->current; tmp = tmp->next)
+	    openfile->current_y += 1 + strlenpt(tmp->data) / COLS;
+
+	openfile->current_y += xplustabs() / COLS;
+	if (openfile->current_y < editwinrows)
+	    wmove(edit, openfile->current_y, xpt % COLS);
+    } else {
+	openfile->current_y = openfile->current->lineno -
+	    openfile->edittop->lineno;
+
+	if (openfile->current_y < editwinrows)
+	    wmove(edit, openfile->current_y, xpt - get_page_start(xpt));
+    }
+}
+
+/* edit_draw() takes care of the job of actually painting a line into
+ * the edit window.  fileptr is the line to be painted, at row line of
+ * the window.  converted is the actual string to be written to the
+ * window, with tabs and control characters replaced by strings of
+ * regular characters.  start is the column number of the first
+ * character of this page.  That is, the first character of converted
+ * corresponds to character number actual_x(fileptr->data, start) of the
+ * line. */
+void edit_draw(filestruct *fileptr, const char *converted, int
+	line, size_t start)
+{
+#if !defined(NANO_TINY) || defined(ENABLE_COLOR)
+    size_t startpos = actual_x(fileptr->data, start);
+	/* The position in fileptr->data of the leftmost character
+	 * that displays at least partially on the window. */
+    size_t endpos = actual_x(fileptr->data, start + COLS - 1) + 1;
+	/* The position in fileptr->data of the first character that is
+	 * completely off the window to the right.
+	 *
+	 * Note that endpos might be beyond the null terminator of the
+	 * string. */
+#endif
+
+    assert(openfile != NULL && fileptr != NULL && converted != NULL);
+    assert(strlenpt(converted) <= COLS);
+
+    /* Just paint the string in any case (we'll add color or reverse on
+     * just the text that needs it). */
+    mvwaddstr(edit, line, 0, converted);
+
+#ifdef ENABLE_COLOR
+    /* If color syntaxes are available and turned on, we need to display
+     * them. */
+    if (openfile->colorstrings != NULL && !ISSET(NO_COLOR_SYNTAX)) {
+	const colortype *tmpcolor = openfile->colorstrings;
+
+	/* Set up multi-line color data for this line if it's not yet calculated  */
+        if (fileptr->multidata == NULL && openfile->syntax
+		&& openfile->syntax->nmultis > 0) {
+ 	    int i;
+	    fileptr->multidata = (short *) nmalloc(openfile->syntax->nmultis * sizeof(short));
+            for (i = 0; i < openfile->syntax->nmultis; i++)
+		fileptr->multidata[i] = -1;	/* Assue this applies until we know otherwise */
+	}
+	for (; tmpcolor != NULL; tmpcolor = tmpcolor->next) {
+	    int x_start;
+		/* Starting column for mvwaddnstr.  Zero-based. */
+	    int paintlen;
+		/* Number of chars to paint on this line.  There are
+		 * COLS characters on a whole line. */
+	    size_t index;
+		/* Index in converted where we paint. */
+	    regmatch_t startmatch;
+		/* Match position for start_regex. */
+	    regmatch_t endmatch;
+		/* Match position for end_regex. */
+
+	    if (tmpcolor->bright)
+		wattron(edit, A_BOLD);
+	    wattron(edit, COLOR_PAIR(tmpcolor->pairnum));
+	    /* Two notes about regexec().  A return value of zero means
+	     * that there is a match.  Also, rm_eo is the first
+	     * non-matching character after the match. */
+
+	    /* First case, tmpcolor is a single-line expression. */
+	    if (tmpcolor->end == NULL) {
+		size_t k = 0;
+
+		/* We increment k by rm_eo, to move past the end of the
+		 * last match.  Even though two matches may overlap, we
+		 * want to ignore them, so that we can highlight e.g. C
+		 * strings correctly. */
+		while (k < endpos) {
+		    /* Note the fifth parameter to regexec().  It says
+		     * not to match the beginning-of-line character
+		     * unless k is zero.  If regexec() returns
+		     * REG_NOMATCH, there are no more matches in the
+		     * line. */
+		    if (regexec(tmpcolor->start, &fileptr->data[k], 1,
+			&startmatch, (k == 0) ? 0 : REG_NOTBOL) ==
+			REG_NOMATCH)
+			break;
+		    /* Translate the match to the beginning of the
+		     * line. */
+		    startmatch.rm_so += k;
+		    startmatch.rm_eo += k;
+
+		    /* Skip over a zero-length regex match. */
+		    if (startmatch.rm_so == startmatch.rm_eo)
+			startmatch.rm_eo++;
+		    else if (startmatch.rm_so < endpos &&
+			startmatch.rm_eo > startpos) {
+			x_start = (startmatch.rm_so <= startpos) ? 0 :
+				strnlenpt(fileptr->data,
+				startmatch.rm_so) - start;
+
+			index = actual_x(converted, x_start);
+
+			paintlen = actual_x(converted + index,
+				strnlenpt(fileptr->data,
+				startmatch.rm_eo) - start - x_start);
+
+			assert(0 <= x_start && 0 <= paintlen);
+
+			mvwaddnstr(edit, line, x_start, converted +
+				index, paintlen);
+		    }
+		    k = startmatch.rm_eo;
+		}
+	    } else if (fileptr->multidata != NULL && fileptr->multidata[tmpcolor->id] != CNONE) {
+		/* This is a multi-line regex.  There are two steps.
+		 * First, we have to see if the beginning of the line is
+		 * colored by a start on an earlier line, and an end on
+		 * this line or later.
+		 *
+		 * We find the first line before fileptr matching the
+		 * start.  If every match on that line is followed by an
+		 * end, then go to step two.  Otherwise, find the next
+		 * line after start_line matching the end.  If that line
+		 * is not before fileptr, then paint the beginning of
+		 * this line. */
+		const filestruct *start_line = fileptr->prev;
+		    /* The first line before fileptr matching start. */
+		regoff_t start_col;
+		    /* Where it starts in that line. */
+		const filestruct *end_line;
+		short md = fileptr->multidata[tmpcolor->id];
+
+		if (md == -1)
+		    fileptr->multidata[tmpcolor->id] = CNONE; /* until we find out otherwise */
+		else if (md == CNONE)
+		    continue;
+		else if (md == CWHOLELINE) {
+		    mvwaddnstr(edit, line, 0, converted, -1);
+		    continue;
+		} else if (md == CBEGINBEFORE) {
+		    regexec(tmpcolor->end, fileptr->data, 1, &endmatch, 0);
+		    paintlen = actual_x(converted, strnlenpt(fileptr->data,
+			endmatch.rm_eo) - start);
+		    mvwaddnstr(edit, line, 0, converted, paintlen);
+		    continue;
+		}
+
+		while (start_line != NULL && regexec(tmpcolor->start,
+			start_line->data, 1, &startmatch, 0) ==
+			REG_NOMATCH) {
+		    /* If there is an end on this line, there is no need
+		     * to look for starts on earlier lines. */
+		    if (regexec(tmpcolor->end, start_line->data, 0,
+			NULL, 0) == 0)
+			goto step_two;
+		    start_line = start_line->prev;
+		}
+
+		/* Skip over a zero-length regex match. */
+		if (startmatch.rm_so == startmatch.rm_eo)
+		    startmatch.rm_eo++;
+		else {
+		    /* No start found, so skip to the next step. */
+		    if (start_line == NULL)
+			goto step_two;
+		    /* Now start_line is the first line before fileptr
+		     * containing a start match.  Is there a start on
+		     * this line not followed by an end on this line? */
+		    start_col = 0;
+		    while (TRUE) {
+			start_col += startmatch.rm_so;
+			startmatch.rm_eo -= startmatch.rm_so;
+			if (regexec(tmpcolor->end, start_line->data +
+				start_col + startmatch.rm_eo, 0, NULL,
+				(start_col + startmatch.rm_eo == 0) ?
+				0 : REG_NOTBOL) == REG_NOMATCH)
+			    /* No end found after this start. */
+			    break;
+			start_col++;
+			if (regexec(tmpcolor->start, start_line->data +
+				start_col, 1, &startmatch,
+				REG_NOTBOL) == REG_NOMATCH)
+			    /* No later start on this line. */
+			    goto step_two;
+		    }
+		    /* Indeed, there is a start not followed on this
+		     * line by an end. */
+
+		    /* We have already checked that there is no end
+		     * before fileptr and after the start.  Is there an
+		     * end after the start at all?  We don't paint
+		     * unterminated starts. */
+		    end_line = fileptr;
+		    while (end_line != NULL && regexec(tmpcolor->end,
+			end_line->data, 1, &endmatch, 0) == REG_NOMATCH)
+			end_line = end_line->next;
+
+		    /* No end found, or it is too early. */
+		    if (end_line == NULL || (end_line == fileptr &&
+			endmatch.rm_eo <= startpos))
+			goto step_two;
+
+		    /* Now paint the start of fileptr.  If the start of
+		     * fileptr is on a different line from the end,
+		     * paintlen is -1, meaning that everything on the
+		     * line gets painted.  Otherwise, paintlen is the
+		     * expanded location of the end of the match minus
+		     * the expanded location of the beginning of the
+		     * page. */
+		    if (end_line != fileptr) {
+			paintlen = -1;
+			fileptr->multidata[tmpcolor->id] = CWHOLELINE;
+		    } else {
+			paintlen = actual_x(converted,
+				strnlenpt(fileptr->data,
+				endmatch.rm_eo) - start);
+			fileptr->multidata[tmpcolor->id] = CBEGINBEFORE;
+		    }
+		    mvwaddnstr(edit, line, 0, converted, paintlen);
+  step_two:
+		    /* Second step, we look for starts on this line. */
+		    start_col = 0;
+
+		    while (start_col < endpos) {
+			if (regexec(tmpcolor->start, fileptr->data +
+				start_col, 1, &startmatch, (start_col ==
+				0) ? 0 : REG_NOTBOL) == REG_NOMATCH ||
+				start_col + startmatch.rm_so >= endpos)
+			    /* No more starts on this line. */
+			    break;
+			/* Translate the match to be relative to the
+			 * beginning of the line. */
+			startmatch.rm_so += start_col;
+			startmatch.rm_eo += start_col;
+
+			x_start = (startmatch.rm_so <= startpos) ? 0 :
+				strnlenpt(fileptr->data,
+				startmatch.rm_so) - start;
+
+			index = actual_x(converted, x_start);
+
+			if (regexec(tmpcolor->end, fileptr->data +
+				startmatch.rm_eo, 1, &endmatch,
+				(startmatch.rm_eo == 0) ? 0 :
+				REG_NOTBOL) == 0) {
+			    /* Translate the end match to be relative to
+			     * the beginning of the line. */
+			    endmatch.rm_so += startmatch.rm_eo;
+			    endmatch.rm_eo += startmatch.rm_eo;
+			    /* There is an end on this line.  But does
+			     * it appear on this page, and is the match
+			     * more than zero characters long? */
+			    if (endmatch.rm_eo > startpos &&
+				endmatch.rm_eo > startmatch.rm_so) {
+				paintlen = actual_x(converted + index,
+					strnlenpt(fileptr->data,
+					endmatch.rm_eo) - start -
+					x_start);
+
+				assert(0 <= x_start && x_start < COLS);
+
+				mvwaddnstr(edit, line, x_start,
+					converted + index, paintlen);
+				if (paintlen > 0)
+				    fileptr->multidata[tmpcolor->id] = CSTARTENDHERE;
+
+			    }
+			} else {
+			    /* There is no end on this line.  But we
+			     * haven't yet looked for one on later
+			     * lines. */
+			    end_line = fileptr->next;
+
+			    while (end_line != NULL &&
+				regexec(tmpcolor->end, end_line->data,
+				0, NULL, 0) == REG_NOMATCH)
+				end_line = end_line->next;
+
+			    if (end_line != NULL) {
+				assert(0 <= x_start && x_start < COLS);
+
+				mvwaddnstr(edit, line, x_start,
+					converted + index, -1);
+				/* We painted to the end of the line, so
+				 * don't bother checking any more
+				 * starts. */
+				fileptr->multidata[tmpcolor->id] = CENDAFTER;
+				break;
+			    }
+			}
+			start_col = startmatch.rm_so + 1;
+		    }
+		}
+	    }
+
+	    wattroff(edit, A_BOLD);
+	    wattroff(edit, COLOR_PAIR(tmpcolor->pairnum));
+	}
+    }
+#endif /* ENABLE_COLOR */
+
+#ifndef NANO_TINY
+    /* If the mark is on, we need to display it. */
+    if (openfile->mark_set && (fileptr->lineno <=
+	openfile->mark_begin->lineno || fileptr->lineno <=
+	openfile->current->lineno) && (fileptr->lineno >=
+	openfile->mark_begin->lineno || fileptr->lineno >=
+	openfile->current->lineno)) {
+	/* fileptr is at least partially selected. */
+	const filestruct *top;
+	    /* Either current or mark_begin, whichever is first. */
+	size_t top_x;
+	    /* current_x or mark_begin_x, corresponding to top. */
+	const filestruct *bot;
+	size_t bot_x;
+	int x_start;
+	    /* Starting column for mvwaddnstr().  Zero-based. */
+	int paintlen;
+	    /* Number of characters to paint on this line.  There are
+	     * COLS characters on a whole line. */
+	size_t index;
+	    /* Index in converted where we paint. */
+
+	mark_order(&top, &top_x, &bot, &bot_x, NULL);
+
+	if (top->lineno < fileptr->lineno || top_x < startpos)
+	    top_x = startpos;
+	if (bot->lineno > fileptr->lineno || bot_x > endpos)
+	    bot_x = endpos;
+
+	/* The selected bit of fileptr is on this page. */
+	if (top_x < endpos && bot_x > startpos) {
+	    assert(startpos <= top_x);
+
+	    /* x_start is the expanded location of the beginning of the
+	     * mark minus the beginning of the page. */
+	    x_start = strnlenpt(fileptr->data, top_x) - start;
+
+	    /* If the end of the mark is off the page, paintlen is -1,
+	     * meaning that everything on the line gets painted.
+	     * Otherwise, paintlen is the expanded location of the end
+	     * of the mark minus the expanded location of the beginning
+	     * of the mark. */
+	    if (bot_x >= endpos)
+		paintlen = -1;
+	    else
+		paintlen = strnlenpt(fileptr->data, bot_x) - (x_start +
+			start);
+
+	    /* If x_start is before the beginning of the page, shift
+	     * paintlen x_start characters to compensate, and put
+	     * x_start at the beginning of the page. */
+	    if (x_start < 0) {
+		paintlen += x_start;
+		x_start = 0;
+	    }
+
+	    assert(x_start >= 0 && x_start <= strlen(converted));
+
+	    index = actual_x(converted, x_start);
+
+	    if (paintlen > 0)
+		paintlen = actual_x(converted + index, paintlen);
+
+	    wattron(edit, reverse_attr);
+	    mvwaddnstr(edit, line, x_start, converted + index,
+		paintlen);
+	    wattroff(edit, reverse_attr);
+	}
+    }
+#endif /* !NANO_TINY */
+}
+
+/* Just update one line in the edit buffer.  This is basically a wrapper
+ * for edit_draw().  The line will be displayed starting with
+ * fileptr->data[index].  Likely arguments are current_x or zero.
+ * Returns: Number of additiona lines consumed (needed for SOFTWRAP)
+ */
+int update_line(filestruct *fileptr, size_t index)
+{
+    int line = 0;
+    int extralinesused = 0;
+	/* The line in the edit window that we want to update. */
+    char *converted;
+	/* fileptr->data converted to have tabs and control characters
+	 * expanded. */
+    size_t page_start;
+    filestruct *tmp;
+
+    assert(fileptr != NULL);
+
+    if (ISSET(SOFTWRAP)) {
+	for (tmp = openfile->edittop; tmp && tmp != fileptr; tmp = tmp->next) {
+	    line += 1 + (strlenpt(tmp->data) / COLS);
+	}
+    } else
+	line = fileptr->lineno - openfile->edittop->lineno;
+
+    if (line < 0 || line >= editwinrows)
+	return 1;
+
+    /* First, blank out the line. */
+    blank_line(edit, line, 0, COLS);
+
+    /* Next, convert variables that index the line to their equivalent
+     * positions in the expanded line. */
+    if (ISSET(SOFTWRAP))
+	index = 0;
+    else
+	index = strnlenpt(fileptr->data, index);
+    page_start = get_page_start(index);
+
+    /* Expand the line, replacing tabs with spaces, and control
+     * characters with their displayed forms. */
+    converted = display_string(fileptr->data, page_start, COLS, !ISSET(SOFTWRAP));
+
+#ifdef DEBUG
+    if (ISSET(SOFTWRAP) && strlen(converted) >= COLS - 2)
+	    fprintf(stderr, "update_line(): converted(1) line = %s\n", converted);
+#endif
+
+
+    /* Paint the line. */
+    edit_draw(fileptr, converted, line, page_start);
+    free(converted);
+
+    if (!ISSET(SOFTWRAP)) {
+	if (page_start > 0)
+	    mvwaddch(edit, line, 0, '$');
+	if (strlenpt(fileptr->data) > page_start + COLS)
+	    mvwaddch(edit, line, COLS - 1, '$');
+    } else {
+        int full_length = strlenpt(fileptr->data);
+	for (index += COLS; index <= full_length && line < editwinrows; index += COLS) {
+	    line++;
+#ifdef DEBUG
+	    fprintf(stderr, "update_line(): Softwrap code, moving to %d index %lu\n", line, (unsigned long) index);
+#endif
+ 	    blank_line(edit, line, 0, COLS);
+
+	    /* Expand the line, replacing tabs with spaces, and control
+ 	     * characters with their displayed forms. */
+	    converted = display_string(fileptr->data, index, COLS, !ISSET(SOFTWRAP));
+#ifdef DEBUG
+	    if (ISSET(SOFTWRAP) && strlen(converted) >= COLS - 2)
+		fprintf(stderr, "update_line(): converted(2) line = %s\n", converted);
+#endif
+
+	    /* Paint the line. */
+	    edit_draw(fileptr, converted, line, index);
+ 	    free(converted);
+	    extralinesused++;
+	}
+    }
+    return extralinesused;
+}
+
+/* Return TRUE if we need an update after moving horizontally, and FALSE
+ * otherwise.  We need one if the mark is on or if pww_save and
+ * placewewant are on different pages. */
+bool need_horizontal_update(size_t pww_save)
+{
+    return
+#ifndef NANO_TINY
+	openfile->mark_set ||
+#endif
+	get_page_start(pww_save) !=
+	get_page_start(openfile->placewewant);
+}
+
+/* Return TRUE if we need an update after moving vertically, and FALSE
+ * otherwise.  We need one if the mark is on or if pww_save and
+ * placewewant are on different pages. */
+bool need_vertical_update(size_t pww_save)
+{
+    return
+#ifndef NANO_TINY
+	openfile->mark_set ||
+#endif
+	get_page_start(pww_save) !=
+	get_page_start(openfile->placewewant);
+}
+
+/* When edittop changes, try and figure out how many lines
+ * we really have to work with (i.e. set maxrows)
+ */
+void compute_maxrows(void)
+{
+    int n;
+    filestruct *foo = openfile->edittop;
+
+    if (!ISSET(SOFTWRAP)) {
+	maxrows = editwinrows;
+	return;
+    }
+
+    maxrows = 0;
+    for (n = 0; n < editwinrows && foo; n++) {
+	maxrows ++;
+	n += strlenpt(foo->data) / COLS;
+	foo = foo->next;
+    }
+
+    if (n < editwinrows)
+	maxrows += editwinrows - n;
+
+#ifdef DEBUG
+    fprintf(stderr, "compute_maxrows(): maxrows = %ld\n", maxrows);
+#endif
+}
+
+/* Scroll the edit window in the given direction and the given number
+ * of lines, and draw new lines on the blank lines left after the
+ * scrolling.  direction is the direction to scroll, either UP_DIR or
+ * DOWN_DIR, and nlines is the number of lines to scroll.  We change
+ * edittop, and assume that current and current_x are up to date.  We
+ * also assume that scrollok(edit) is FALSE. */
+void edit_scroll(scroll_dir direction, ssize_t nlines)
+{
+    filestruct *foo;
+    ssize_t i, extracuzsoft = 0;
+    bool do_redraw = FALSE;
+
+    /* Don't bother scrolling less than one line. */
+    if (nlines < 1)
+	return;
+
+    if (need_vertical_update(0))
+	do_redraw = TRUE;
+
+
+    /* If using soft wrapping, we want to scroll down enough to display the entire next
+        line, if possible... */
+    if (ISSET(SOFTWRAP) && direction == DOWN_DIR) {
+#ifdef DEBUG
+	   fprintf(stderr, "Softwrap: Entering check for extracuzsoft\n");
+#endif
+	for (i = maxrows, foo = openfile->edittop; foo && i > 0; i--, foo = foo->next)
+	    ;
+
+	if (foo) {
+	   extracuzsoft += strlenpt(foo->data) / COLS;
+#ifdef DEBUG
+	   fprintf(stderr, "Setting extracuzsoft to %lu due to strlen %lu of line %lu\n", (unsigned long) extracuzsoft,
+		(unsigned long) strlenpt(foo->data), (unsigned long) foo->lineno);
+#endif
+
+	    /* Now account for whether the edittop line itself is >COLS, if scrolling down */
+	   for (foo = openfile->edittop; foo && extracuzsoft > 0; nlines++) {
+		extracuzsoft -= 1 + strlenpt(foo->data) / COLS;
+#ifdef DEBUG
+ 		fprintf(stderr, "Edittop adjustment, setting nlines to %lu\n", (unsigned long) nlines);
+#endif
+		if (foo == openfile->filebot)
+		    break;
+		foo = foo->next;
+	    }
+	}
+    }
+
+    /* Part 1: nlines is the number of lines we're going to scroll the
+     * text of the edit window. */
+
+    /* Move the top line of the edit window up or down (depending on the
+     * value of direction) nlines lines, or as many lines as we can if
+     * there are fewer than nlines lines available. */
+    for (i = nlines; i > 0; i--) {
+	if (direction == UP_DIR) {
+	    if (openfile->edittop == openfile->fileage)
+		break;
+	    openfile->edittop = openfile->edittop->prev;
+	} else {
+	    if (openfile->edittop == openfile->filebot)
+		break;
+	    openfile->edittop = openfile->edittop->next;
+	}
+	/* Don't over-scroll on long lines */
+	if (ISSET(SOFTWRAP)) {
+	    ssize_t len = strlenpt(openfile->edittop->data) / COLS;
+	    i -=  len;
+	    if (len > 0)
+		do_redraw = TRUE;
+	}
+    }
+
+    /* Limit nlines to the number of lines we could scroll. */
+    nlines -= i;
+
+    /* Don't bother scrolling zero lines or more than the number of
+     * lines in the edit window minus one; in both cases, get out, and
+     * call edit_refresh() beforehand if we need to. */
+    if (nlines == 0 || do_redraw || nlines >= editwinrows) {
+	if (do_redraw || nlines >= editwinrows)
+	    edit_refresh_needed = TRUE;
+	return;
+    }
+
+    /* Scroll the text of the edit window up or down nlines lines,
+     * depending on the value of direction. */
+    scrollok(edit, TRUE);
+    wscrl(edit, (direction == UP_DIR) ? -nlines : nlines);
+    scrollok(edit, FALSE);
+
+    /* Part 2: nlines is the number of lines in the scrolled region of
+     * the edit window that we need to draw. */
+
+    /* If the top or bottom line of the file is now visible in the edit
+     * window, we need to draw the entire edit window. */
+    if ((direction == UP_DIR && openfile->edittop ==
+	openfile->fileage) || (direction == DOWN_DIR &&
+	openfile->edittop->lineno + editwinrows - 1 >=
+	openfile->filebot->lineno))
+	nlines = editwinrows;
+
+    /* If the scrolled region contains only one line, and the line
+     * before it is visible in the edit window, we need to draw it too.
+     * If the scrolled region contains more than one line, and the lines
+     * before and after the scrolled region are visible in the edit
+     * window, we need to draw them too. */
+    nlines += (nlines == 1) ? 1 : 2;
+
+    if (nlines > editwinrows)
+	nlines = editwinrows;
+
+    /* If we scrolled up, we're on the line before the scrolled
+     * region. */
+    foo = openfile->edittop;
+
+    /* If we scrolled down, move down to the line before the scrolled
+     * region. */
+    if (direction == DOWN_DIR) {
+	for (i = editwinrows - nlines; i > 0 && foo != NULL; i--)
+	    foo = foo->next;
+    }
+
+    /* Draw new lines on any blank lines before or inside the scrolled
+     * region.  If we scrolled down and we're on the top line, or if we
+     * scrolled up and we're on the bottom line, the line won't be
+     * blank, so we don't need to draw it unless the mark is on or we're
+     * not on the first page. */
+    for (i = nlines; i > 0 && foo != NULL; i--) {
+	if ((i == nlines && direction == DOWN_DIR) || (i == 1 &&
+		direction == UP_DIR)) {
+	    if (do_redraw)
+		update_line(foo, (foo == openfile->current) ?
+			openfile->current_x : 0);
+	} else
+	    update_line(foo, (foo == openfile->current) ?
+		openfile->current_x : 0);
+	foo = foo->next;
+    }
+}
+
+/* Update any lines between old_current and current that need to be
+ * updated.  Use this if we've moved without changing any text. */
+void edit_redraw(filestruct *old_current, size_t pww_save)
+{
+    bool do_redraw = need_vertical_update(0) ||
+	need_vertical_update(pww_save);
+    filestruct *foo = NULL;
+
+    /* If either old_current or current is offscreen, scroll the edit
+     * window until it's onscreen and get out. */
+    if (old_current->lineno < openfile->edittop->lineno ||
+	old_current->lineno >= openfile->edittop->lineno +
+	maxrows || openfile->current->lineno <
+	openfile->edittop->lineno || openfile->current->lineno >=
+	openfile->edittop->lineno + maxrows) {
+
+#ifdef DEBUG
+    fprintf(stderr, "edit_redraw(): line %lu was offscreen, oldcurrent = %lu edittop = %lu", openfile->current->lineno,
+                    old_current->lineno, openfile->edittop->lineno);
+#endif
+	filestruct *old_edittop = openfile->edittop;
+
+#ifndef NANO_TINY
+	/* If the mark is on, update all the lines between old_current
+	 * and either the old first line or old last line (depending on
+	 * whether we've scrolled up or down) of the edit window. */
+	if (openfile->mark_set) {
+	    ssize_t old_lineno;
+
+	    if (old_edittop->lineno < openfile->edittop->lineno)
+		old_lineno = old_edittop->lineno;
+	    else
+		old_lineno = (old_edittop->lineno + maxrows <=
+			openfile->filebot->lineno) ?
+			old_edittop->lineno + editwinrows :
+			openfile->filebot->lineno;
+
+	    foo = old_current;
+
+	    while (foo->lineno != old_lineno) {
+		update_line(foo, 0);
+
+		foo = (foo->lineno > old_lineno) ? foo->prev :
+			foo->next;
+	    }
+	}
+#endif /* !NANO_TINY */
+
+	/* Put edittop in range of current, get the difference in lines
+	 * between the original edittop and the current edittop, and
+	 * then restore the original edittop. */
+	edit_update(CENTER);
+
+	/* Update old_current if we're not on the same page as
+	 * before. */
+	if (do_redraw)
+	    update_line(old_current, 0);
+
+#ifndef NANO_TINY
+	/* If the mark is on, update all the lines between the old first
+	 * line or old last line of the edit window (depending on
+	 * whether we've scrolled up or down) and current. */
+	if (openfile->mark_set) {
+	    while (foo->lineno != openfile->current->lineno) {
+		update_line(foo, 0);
+
+		foo = (foo->lineno > openfile->current->lineno) ?
+			foo->prev : foo->next;
+	    }
+	}
+#endif /* !NANO_TINY */
+
+	return;
+    }
+
+    /* Update old_current and current if we're not on the same page as
+     * before.  If the mark is on, update all the lines between
+     * old_current and current too. */
+    foo = old_current;
+
+    while (foo != openfile->current) {
+	if (do_redraw)
+	    update_line(foo, 0);
+
+#ifndef NANO_TINY
+	if (!openfile->mark_set)
+#endif
+	    break;
+
+#ifndef NANO_TINY
+	foo = (foo->lineno > openfile->current->lineno) ? foo->prev :
+		foo->next;
+#endif
+    }
+
+    if (do_redraw)
+	update_line(openfile->current, openfile->current_x);
+}
+
+/* Refresh the screen without changing the position of lines.  Use this
+ * if we've moved and changed text. */
+void edit_refresh(void)
+{
+    filestruct *foo;
+    int nlines;
+
+    /* Figure out what maxrows should really be */
+    compute_maxrows();
+
+    if (openfile->current->lineno < openfile->edittop->lineno ||
+	openfile->current->lineno >= openfile->edittop->lineno +
+	maxrows) {
+
+#ifdef DEBUG
+    fprintf(stderr, "edit_refresh(): line = %d, edittop %d + maxrows %d\n", openfile->current->lineno, openfile->edittop->lineno, maxrows);
+#endif
+
+	/* Put the top line of the edit window in range of the current
+	 * line. */
+	edit_update(CENTER);
+    }
+
+    foo = openfile->edittop;
+
+#ifdef DEBUG
+    fprintf(stderr, "edit_refresh(): edittop->lineno = %ld\n", (long)openfile->edittop->lineno);
+#endif
+
+    for (nlines = 0; nlines < editwinrows && foo != NULL; nlines++) {
+	nlines += update_line(foo, (foo == openfile->current) ?
+		openfile->current_x : 0);
+	foo = foo->next;
+    }
+
+    for (; nlines < editwinrows; nlines++)
+	blank_line(edit, nlines, 0, COLS);
+
+    reset_cursor();
+    wnoutrefresh(edit);
+}
+
+/* Move edittop to put it in range of current, keeping current in the
+ * same place.  location determines how we move it: if it's CENTER, we
+ * center current, and if it's NONE, we put current current_y lines
+ * below edittop. */
+void edit_update(update_type location)
+{
+    filestruct *foo = openfile->current;
+    int goal;
+
+    /* If location is CENTER, we move edittop up (editwinrows / 2)
+     * lines.  This puts current at the center of the screen.  If
+     * location is NONE, we move edittop up current_y lines if current_y
+     * is in range of the screen, 0 lines if current_y is less than 0,
+     * or (editwinrows - 1) lines if current_y is greater than
+     * (editwinrows - 1).  This puts current at the same place on the
+     * screen as before, or at the top or bottom of the screen if
+     * edittop is beyond either. */
+    if (location == CENTER)
+	goal = editwinrows / 2;
+    else {
+	goal = openfile->current_y;
+
+	/* Limit goal to (editwinrows - 1) lines maximum. */
+	if (goal > editwinrows - 1)
+	    goal = editwinrows - 1;
+    }
+
+    for (; goal > 0 && foo->prev != NULL; goal--) {
+	foo = foo->prev;
+	if (ISSET(SOFTWRAP) && foo)
+	    goal -= strlenpt(foo->data) / COLS;
+    }
+    openfile->edittop = foo;
+#ifdef DEBUG
+    fprintf(stderr, "edit_udpate(), setting edittop to lineno %d\n", openfile->edittop->lineno);
+#endif
+    compute_maxrows();
+    edit_refresh_needed = TRUE;
+}
+
+/* Unconditionally redraw the entire screen. */
+void total_redraw(void)
+{
+#ifdef USE_SLANG
+    /* Slang curses emulation brain damage, part 4: Slang doesn't define
+     * curscr. */
+    SLsmg_touch_screen();
+    SLsmg_refresh();
+#else
+    wrefresh(curscr);
+#endif
+}
+
+/* Unconditionally redraw the entire screen, and then refresh it using
+ * the current file. */
+void total_refresh(void)
+{
+    total_redraw();
+    titlebar(NULL);
+    edit_refresh();
+    bottombars(currmenu);
+}
+
+/* Display the main shortcut list on the last two rows of the bottom
+ * portion of the window. */
+void display_main_list(void)
+{
+    bottombars(MMAIN);
+}
+
+/* If constant is TRUE, we display the current cursor position only if
+ * disable_cursorpos is FALSE.  Otherwise, we display it
+ * unconditionally and set disable_cursorpos to FALSE.  If constant is
+ * TRUE and disable_cursorpos is TRUE, we also set disable_cursorpos to
+ * FALSE, so that we leave the current statusbar alone this time, and
+ * display the current cursor position next time. */
+void do_cursorpos(bool constant)
+{
+    filestruct *f;
+    char c;
+    size_t i, cur_xpt = xplustabs() + 1;
+    size_t cur_lenpt = strlenpt(openfile->current->data) + 1;
+    int linepct, colpct, charpct;
+
+    assert(openfile->fileage != NULL && openfile->current != NULL);
+
+    f = openfile->current->next;
+    c = openfile->current->data[openfile->current_x];
+
+    openfile->current->next = NULL;
+    openfile->current->data[openfile->current_x] = '\0';
+
+    i = get_totsize(openfile->fileage, openfile->current);
+
+    openfile->current->data[openfile->current_x] = c;
+    openfile->current->next = f;
+
+    if (constant && disable_cursorpos) {
+	disable_cursorpos = FALSE;
+	return;
+    }
+
+    /* Display the current cursor position on the statusbar, and set
+     * disable_cursorpos to FALSE. */
+    linepct = 100 * openfile->current->lineno /
+	openfile->filebot->lineno;
+    colpct = 100 * cur_xpt / cur_lenpt;
+    charpct = (openfile->totsize == 0) ? 0 : 100 * i /
+	openfile->totsize;
+
+    statusbar(
+	_("line %ld/%ld (%d%%), col %lu/%lu (%d%%), char %lu/%lu (%d%%)"),
+	(long)openfile->current->lineno,
+	(long)openfile->filebot->lineno, linepct,
+	(unsigned long)cur_xpt, (unsigned long)cur_lenpt, colpct,
+	(unsigned long)i, (unsigned long)openfile->totsize, charpct);
+
+    disable_cursorpos = FALSE;
+}
+
+/* Unconditionally display the current cursor position. */
+void do_cursorpos_void(void)
+{
+    do_cursorpos(FALSE);
+}
+
+void enable_nodelay(void)
+{
+   nodelay_mode = TRUE;
+   nodelay(edit, TRUE);
+}
+
+void disable_nodelay(void)
+{
+   nodelay_mode = FALSE;
+   nodelay(edit, FALSE);
+}
+
+
+/* Highlight the current word being replaced or spell checked.  We
+ * expect word to have tabs and control characters expanded. */
+void do_replace_highlight(bool highlight, const char *word)
+{
+    size_t y = xplustabs(), word_len = strlenpt(word);
+
+    y = get_page_start(y) + COLS - y;
+	/* Now y is the number of columns that we can display on this
+	 * line. */
+
+    assert(y > 0);
+
+    if (word_len > y)
+	y--;
+
+    reset_cursor();
+    wnoutrefresh(edit);
+
+    if (highlight)
+	wattron(edit, reverse_attr);
+
+    /* This is so we can show zero-length matches. */
+    if (word_len == 0)
+	waddch(edit, ' ');
+    else
+	waddnstr(edit, word, actual_x(word, y));
+
+    if (word_len > y)
+	waddch(edit, '$');
+
+    if (highlight)
+	wattroff(edit, reverse_attr);
+}
+
+#ifdef NANO_EXTRA
+#define CREDIT_LEN 55
+#define XLCREDIT_LEN 8
+
+/* Easter egg: Display credits.  Assume nodelay(edit) and scrollok(edit)
+ * are FALSE. */
+void do_credits(void)
+{
+    bool old_more_space = ISSET(MORE_SPACE);
+    bool old_no_help = ISSET(NO_HELP);
+    int kbinput = ERR, crpos = 0, xlpos = 0;
+    const char *credits[CREDIT_LEN] = {
+	NULL,				/* "The nano text editor" */
+	NULL,				/* "version" */
+	VERSION,
+	"",
+	NULL,				/* "Brought to you by:" */
+	"Chris Allegretta",
+	"Jordi Mallach",
+	"Adam Rogoyski",
+	"Rob Siemborski",
+	"Rocco Corsi",
+	"David Lawrence Ramsey",
+	"David Benbennick",
+	"Mike Frysinger",
+	"Ken Tyler",
+	"Sven Guckes",
+	NULL,				/* credits[15], handled below. */
+	"Pauli Virtanen",
+	"Daniele Medri",
+	"Clement Laforet",
+	"Tedi Heriyanto",
+	"Bill Soudan",
+	"Christian Weisgerber",
+	"Erik Andersen",
+	"Big Gaute",
+	"Joshua Jensen",
+	"Ryan Krebs",
+	"Albert Chin",
+	"",
+	NULL,				/* "Special thanks to:" */
+	"Plattsburgh State University",
+	"Benet Laboratories",
+	"Amy Allegretta",
+	"Linda Young",
+	"Jeremy Robichaud",
+	"Richard Kolb II",
+	NULL,				/* "The Free Software Foundation" */
+	"Linus Torvalds",
+	NULL,				/* "For ncurses:" */
+	"Thomas Dickey",
+	"Pavel Curtis",
+	"Zeyd Ben-Halim",
+	"Eric S. Raymond",
+	NULL,				/* "and anyone else we forgot..." */
+	NULL,				/* "Thank you for using nano!" */
+	"",
+	"",
+	"",
+	"",
+	"(C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007",
+	"Free Software Foundation, Inc.",
+	"",
+	"",
+	"",
+	"",
+	"http://www.nano-editor.org/"
+    };
+
+    const char *xlcredits[XLCREDIT_LEN] = {
+	N_("The nano text editor"),
+	N_("version"),
+	N_("Brought to you by:"),
+	N_("Special thanks to:"),
+	N_("The Free Software Foundation"),
+	N_("For ncurses:"),
+	N_("and anyone else we forgot..."),
+	N_("Thank you for using nano!")
+    };
+
+    /* credits[15]: Make sure this name is displayed properly, since we
+     * can't dynamically assign it above, using Unicode 00F6 (Latin
+     * Small Letter O with Diaresis) if applicable. */
+    credits[15] =
+#ifdef ENABLE_UTF8
+	 using_utf8() ? "Florian K\xC3\xB6nig" :
+#endif
+	"Florian K\xF6nig";
+
+    if (!old_more_space || !old_no_help) {
+	SET(MORE_SPACE);
+	SET(NO_HELP);
+	window_init();
+    }
+
+    curs_set(0);
+    nodelay(edit, TRUE);
+
+    blank_titlebar();
+    blank_topbar();
+    blank_edit();
+    blank_statusbar();
+    blank_bottombars();
+
+    wrefresh(topwin);
+    wrefresh(edit);
+    wrefresh(bottomwin);
+    napms(700);
+
+    for (crpos = 0; crpos < CREDIT_LEN + editwinrows / 2; crpos++) {
+	if ((kbinput = wgetch(edit)) != ERR)
+	    break;
+
+	if (crpos < CREDIT_LEN) {
+	    const char *what;
+	    size_t start_x;
+
+	    if (credits[crpos] == NULL) {
+		assert(0 <= xlpos && xlpos < XLCREDIT_LEN);
+
+		what = _(xlcredits[xlpos]);
+		xlpos++;
+	    } else
+		what = credits[crpos];
+
+	    start_x = COLS / 2 - strlenpt(what) / 2 - 1;
+	    mvwaddstr(edit, editwinrows - 1 - (editwinrows % 2),
+		start_x, what);
+	}
+
+	wrefresh(edit);
+
+	if ((kbinput = wgetch(edit)) != ERR)
+	    break;
+	napms(700);
+
+	scrollok(edit, TRUE);
+	wscrl(edit, 1);
+	scrollok(edit, FALSE);
+	wrefresh(edit);
+
+	if ((kbinput = wgetch(edit)) != ERR)
+	    break;
+	napms(700);
+
+	scrollok(edit, TRUE);
+	wscrl(edit, 1);
+	scrollok(edit, FALSE);
+	wrefresh(edit);
+    }
+
+    if (kbinput != ERR)
+	ungetch(kbinput);
+
+    if (!old_more_space || !old_no_help) {
+	UNSET(MORE_SPACE);
+	UNSET(NO_HELP);
+	window_init();
+    }
+
+    curs_set(1);
+    nodelay(edit, FALSE);
+
+    total_refresh();
+}
+#endif /* NANO_EXTRA */