D34411.1794622443.diff
No OneTemporary
Actions

Authored By

Unknown

Size

997 KB

Referenced Files

None

Subscribers

None

D34411.1794622443.diff
View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	Index: contrib/mg/NOTES.md
	===================================================================
	--- /dev/null
	+++ contrib/mg/NOTES.md
	@@ -0,0 +1,5 @@
	+NOTES
	+
	+* On some Linux distributions, the backspace key doesn't work
	+ correctly. This can be fixed with `bsmap-mode`; this should probably
	+ be placed in the user's `$HOME/.mg` file.
	Index: contrib/mg/README-Mg
	===================================================================
	--- /dev/null
	+++ contrib/mg/README-Mg
	@@ -0,0 +1,93 @@
	+[This is an edited version of the original mg README, updated slightly to
	+reflect changes in the last 20 years.]
	+
	+
	+Mg (mg) is a Public Domain EMACS style editor. It is "broadly"
	+compatible with GNU Emacs, the latest creation of Richard M.
	+Stallman, Chief GNUisance and inventor of Emacs. GNU Emacs (and other
	+portions of GNU as they are released) are essentially free, (there are
	+handling charges for obtaining it) and so is Mg. You may never have
	+to learn another editor. (But probably will, at least long enough to
	+port Mg...) Mg was formerly named MicroGnuEmacs, the name change was
	+done at the request of Richard Stallman.
	+
	+Mg is not associated with the GNU project, and it does not have the
	+copyright restrictions present in GNU Emacs. (However, some modules
	+do have copyright notices.) The Mg authors individually may or may
	+not agree with the opinions expressed by Richard Stallman in "The GNU
	+Manifesto".
	+
	+This program is intended to be a small, fast, and portable editor for
	+people who can't (or don't want to) run real Emacs for one reason
	+or another. It is compatible with GNU because there shouldn't be
	+any reason to learn more than one Emacs flavor.
	+
	+
	+Beyond the work of Dave Conroy, author of the original public domain
	+v30, the current version contains the work of:
	+
	+ blarson@ecla.usc.edu Bob Larson
	+ mic@emx.utexas.edu Mic Kaczmarczik
	+ mwm@violet.berkeley.edu Mike Meyer
	+ sandra@cs.utah.edu Sandra Loosemore
	+ mp1u+@andrew.cmu.edu Michael Portuesi
	+ RCKG01M@CALSTATE.BITNET Stephen Walton
	+ hakanson@mist.cs.orst.edu Marion Hakanson
	+
	+People who have worked on previous versions of Mg:
	+
	+ rtech!daveb@sun.com Dave Brower
	+
	+Early release history:
	+
	+* Nov 16, 1986: First release to mod.sources
	+* Mar 3, 1987: First Release (mg1a) via comp.sources.unix
	+* May 26, 1988: Second release: (mg2a) via comp.sources.misc
	+* Jan 26, 1992: Linux port released by Charles Hedrick. This version
	+ later makes its way onto tsx-11, Infomagic, and various other Linux
	+ repositories.
	+* Feb 25, 2000: First import into the OpenBSD tree, where it is
	+ currently maintained with contributions from many others.
	+
	+----------------------------------------------------------------------
	+
	+Known limitations:
	+
	+Recursive bindings may cause help and key rebinding code to go into
	+an infinite loop, aborting with a stack overflow.
	+
	+Overwrite mode does not work in macros. (Characters are inserted
	+rather than overwriting.)
	+
	+Dired mode has some problems: Rename does not update the buffer.
	+Doing a dired again will update the buffer (whether it needs it or
	+not) and will lose any marks for deletion. .. and . are not
	+recognized as special cases.
	+
	+On systems with 16 bit integers, the kill buffer cannot exceed 32767
	+bytes.
	+
	+Unlike GNU Emacs, Mg's minibuffer isn't multi-line aware and hence
	+some commands like "shell-command-on-region" always pop up a buffer to
	+display output irrespective of output's size.
	+
	+While navigating source code using Mg's cscope commands, the cursor
	+is always at the match location rather than in cscope buffer. Mg uses
	+the same keybindings of GNU Emacs's xcscope package for it's cscope commands.
	+As Mg's keybindings are case-insensitive some of the commands don't have a
	+default keybinding.
	+
	+New implementation oddities:
	+
	+insert and define-key are new commands corresponding to the mocklisp
	+functions in GNU Emacs. (Mg does not have non-command functions.)
	+(Mg's insert will only insert one string.)
	+
	+The display wrap code does not work at all like that of GNU emacs.
	+
	+Some commands that do not mimic emacs exactly don't have a "standard"
	+emacs name. For example 'backup-to-home-directory' is only a partial
	+implementation of emacs' range of commands that allow a user to
	+customise the backup file location. If a more complete implementation
	+were coded of these commands the non standard commands would probably
	+be removed.
	Index: contrib/mg/README.md
	===================================================================
	--- /dev/null
	+++ contrib/mg/README.md
	@@ -0,0 +1,51 @@
	+mg
	+==
	+This is a portable version of the Mg editor from OpenBSD.
	+
	+Mg is intended to be a small, fast, and portable editor for people who
	+can't (or don't want to) run emacs for one reason or another, or are not
	+familiar with the vi editor. It is compatible with emacs because there
	+shouldn't be any reason to learn more editor types than emacs or vi.
	+
	+This repository aggressively tracks upstream.
	+
	+Compiling
	+---------
	+`mg` has a simple configure script that generates a `POSIX` `Makefile`.
	+```
	+$ ./configure
	+$ make
	+$ sudo make install
	+```
	+
	+Dependencies
	+------------
	+By default, you need the ncurses library.
	+
	+NetBSD users will use the in-base NetBSD curses library.
	+
	+If you do not have the ncurses library, you can call `configure` with the
	+`--with-builtin-curses` flag to compile with a simplified version of the
	+NetBSD curses library. In this setup, there are no dependencies other than
	+the system's libc.
	+
	+Testing
	+-------
	+Tested on recent versions of Arch, Alpine, Cygwin, Debian, DragonFly BSD,
	+FreeBSD, Mac OS X (10.4 or later), NetBSD, Slackware, and Ubuntu.
	+
	+Licensing
	+---------
	+Files originating from `mg` are Public Domain. Files needed for portability
	+have their own individual license headers.
	+All licenses are ISC or BSD.
	+
	+Commonly asked questions
	+------------------------
	+`mg` does not yet support UTF-8. If you would like to work on this, please
	+reach out to the tech@ mailing list on OpenBSD.
	+
	+Get a tarball
	+-------------
	+See the Releases tab on GitHub.
	+The latest version is mg-7.0.
	Index: contrib/mg/autoexec.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/autoexec.c
	@@ -0,0 +1,116 @@
	+/* $OpenBSD: autoexec.c,v 1.18 2021/04/21 14:45:28 lum Exp $ */
	+/* this file is in the public domain */
	+/* Author: Vincent Labrecque <vincent@openbsd.org> April 2002 */
	+
	+#include <sys/queue.h>
	+#include <fnmatch.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+
	+#include "def.h"
	+#include "funmap.h"
	+
	+struct autoexec {
	+ SLIST_ENTRY(autoexec) next; /* link in the linked list */
	+ const char pattern; / Pattern to match to filenames */
	+ PF fp;
	+};
	+
	+static SLIST_HEAD(, autoexec) autos;
	+static int ready;
	+
	+
	+#define AUTO_GROW 8
	+/*
	+ * Return a NULL terminated array of function pointers to be called
	+ * when we open a file that matches <fname>. The list must be free(ed)
	+ * after use.
	+ */
	+PF *
	+find_autoexec(const char *fname)
	+{
	+ PF pfl, npfl;
	+ int have, used;
	+ struct autoexec *ae;
	+
	+ if (!ready)
	+ return (NULL);
	+
	+ pfl = NULL;
	+ have = 0;
	+ used = 0;
	+ SLIST_FOREACH(ae, &autos, next) {
	+ if (fnmatch(ae->pattern, fname, 0) == 0) {
	+ if (used >= have) {
	+ npfl = reallocarray(pfl, have + AUTO_GROW + 1,
	+ sizeof(PF));
	+ if (npfl == NULL)
	+ panic("out of memory");
	+ pfl = npfl;
	+ have += AUTO_GROW;
	+ }
	+ pfl[used++] = ae->fp;
	+ }
	+ }
	+ if (used)
	+ pfl[used] = NULL;
	+
	+ return (pfl);
	+}
	+
	+int
	+add_autoexec(const char pattern, const char func)
	+{
	+ PF fp;
	+ struct autoexec *ae;
	+
	+ if (!ready) {
	+ SLIST_INIT(&autos);
	+ ready = 1;
	+ }
	+ fp = name_function(func);
	+ if (fp == NULL)
	+ return (FALSE);
	+ ae = malloc(sizeof(*ae));
	+ if (ae == NULL)
	+ return (FALSE);
	+ ae->fp = fp;
	+ ae->pattern = strdup(pattern);
	+ if (ae->pattern == NULL) {
	+ free(ae);
	+ return (FALSE);
	+ }
	+ SLIST_INSERT_HEAD(&autos, ae, next);
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * Register an auto-execute hook; that is, specify a filename pattern
	+ * (conforming to the shell's filename globbing rules) and an associated
	+ * function to execute when a file matching the specified pattern
	+ * is read into a buffer.
	+*/
	+/* ARGSUSED */
	+int
	+auto_execute(int f, int n)
	+{
	+ char patbuf[BUFSIZE], funcbuf[BUFSIZE], patp, funcp;
	+ int s;
	+
	+ if ((patp = eread("Filename pattern: ", patbuf, sizeof(patbuf),
	+ EFNEW \| EFCR)) == NULL)
	+ return (ABORT);
	+ else if (patp[0] == '\0')
	+ return (FALSE);
	+ if ((funcp = eread("Execute: ", funcbuf, sizeof(funcbuf),
	+ EFNEW \| EFCR \| EFFUNC)) == NULL)
	+ return (ABORT);
	+ else if (funcp[0] == '\0')
	+ return (FALSE);
	+ if ((s = add_autoexec(patp, funcp)) != TRUE)
	+ return (s);
	+ return (TRUE);
	+}
	Index: contrib/mg/basic.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/basic.c
	@@ -0,0 +1,580 @@
	+/* $OpenBSD: basic.c,v 1.50 2021/02/27 13:24:52 lum Exp $ */
	+
	+/* This file is in the public domain */
	+
	+/*
	+ * Basic cursor motion commands.
	+ *
	+ * The routines in this file are the basic
	+ * command functions for moving the cursor around on
	+ * the screen, setting mark, and swapping dot with
	+ * mark. Only moves between lines, which might make the
	+ * current buffer framing bad, are hard.
	+ */
	+
	+#include <sys/queue.h>
	+#include <ctype.h>
	+#include <limits.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+
	+#include "def.h"
	+
	+#define percint(n1, n2) ((n1 * (int) n2) * 0.1)
	+
	+/*
	+ * Go to beginning of line.
	+ */
	+/* ARGSUSED */
	+int
	+gotobol(int f, int n)
	+{
	+ if (n == 0)
	+ return (TRUE);
	+
	+ curwp->w_doto = 0;
	+ return (TRUE);
	+}
	+
	+/*
	+ * Move cursor backwards. Do the
	+ * right thing if the count is less than
	+ * 0. Error if you try to move back from
	+ * the beginning of the buffer.
	+ */
	+/* ARGSUSED */
	+int
	+backchar(int f, int n)
	+{
	+ struct line *lp;
	+
	+ if (n < 0)
	+ return (forwchar(f, -n));
	+ while (n--) {
	+ if (curwp->w_doto == 0) {
	+ if ((lp = lback(curwp->w_dotp)) == curbp->b_headp) {
	+ if (!(f & FFRAND))
	+ (void)dobeep_msg("Beginning "
	+ "of buffer");
	+ return (FALSE);
	+ }
	+ curwp->w_dotp = lp;
	+ curwp->w_doto = llength(lp);
	+ curwp->w_rflag \|= WFMOVE;
	+ curwp->w_dotline--;
	+ } else
	+ curwp->w_doto--;
	+ }
	+ return (TRUE);
	+}
	+
	+/*
	+ * Go to end of line.
	+ */
	+/* ARGSUSED */
	+int
	+gotoeol(int f, int n)
	+{
	+ if (n == 0)
	+ return (TRUE);
	+
	+ curwp->w_doto = llength(curwp->w_dotp);
	+ return (TRUE);
	+}
	+
	+/*
	+ * Move cursor forwards. Do the
	+ * right thing if the count is less than
	+ * 0. Error if you try to move forward
	+ * from the end of the buffer.
	+ */
	+/* ARGSUSED */
	+int
	+forwchar(int f, int n)
	+{
	+ if (n < 0)
	+ return (backchar(f, -n));
	+ while (n--) {
	+ if (curwp->w_doto == llength(curwp->w_dotp)) {
	+ curwp->w_dotp = lforw(curwp->w_dotp);
	+ if (curwp->w_dotp == curbp->b_headp) {
	+ curwp->w_dotp = lback(curwp->w_dotp);
	+ if (!(f & FFRAND))
	+ (void)dobeep_msg("End of buffer");
	+ return (FALSE);
	+ }
	+ curwp->w_doto = 0;
	+ curwp->w_dotline++;
	+ curwp->w_rflag \|= WFMOVE;
	+ } else
	+ curwp->w_doto++;
	+ }
	+ return (TRUE);
	+}
	+
	+/*
	+ * Go to the beginning of the buffer. Setting WFFULL is conservative,
	+ * but almost always the case. A universal argument of higher than 9
	+ * puts the cursor back to the end of buffer.
	+ */
	+int
	+gotobob(int f, int n)
	+{
	+ if (!curwp->w_markp)
	+ (void) setmark(f, n);
	+ curwp->w_dotp = bfirstlp(curbp);
	+ curwp->w_doto = 0;
	+ curwp->w_rflag \|= WFFULL;
	+ curwp->w_dotline = 1;
	+ if (f & FFOTHARG && n > 0) {
	+ if (n > 9)
	+ gotoeob(0, 0);
	+ else
	+ forwline(f, percint(curwp->w_bufp->b_lines, n) - 1);
	+ }
	+ return (TRUE);
	+}
	+
	+/*
	+ * Go to the end of the buffer. Leave dot 3 lines from the bottom of the
	+ * window if buffer length is longer than window length; same as emacs.
	+ * Setting WFFULL is conservative, but almost always the case. A universal
	+ * argument of higher than 9 puts the cursor back to the start of buffer.
	+ */
	+int
	+gotoeob(int f, int n)
	+{
	+ int ln;
	+ struct line *lp;
	+
	+ if (!curwp->w_markp)
	+ (void) setmark(f, n);
	+ curwp->w_dotp = blastlp(curbp);
	+ curwp->w_doto = llength(curwp->w_dotp);
	+ curwp->w_dotline = curwp->w_bufp->b_lines;
	+
	+ lp = curwp->w_dotp;
	+ ln = curwp->w_ntrows - 3;
	+
	+ if (ln < curwp->w_bufp->b_lines && ln >= 3) {
	+ while (ln--)
	+ curwp->w_dotp = lback(curwp->w_dotp);
	+
	+ curwp->w_linep = curwp->w_dotp;
	+ curwp->w_dotp = lp;
	+ }
	+ if (f & FFOTHARG && n > 0) {
	+ if (n > 9)
	+ gotobob(0, 0);
	+ else
	+ backline(f, percint(curwp->w_bufp->b_lines, n));
	+ }
	+
	+ curwp->w_rflag \|= WFFULL;
	+ return (TRUE);
	+}
	+
	+/*
	+ * Move forward by full lines.
	+ * If the number of lines to move is less
	+ * than zero, call the backward line function to
	+ * actually do it. The last command controls how
	+ * the goal column is set.
	+ */
	+/* ARGSUSED */
	+int
	+forwline(int f, int n)
	+{
	+ struct line *dlp;
	+
	+ if (n < 0)
	+ return (backline(f \| FFRAND, -n));
	+ if ((dlp = curwp->w_dotp) == curbp->b_headp) {
	+ if (!(f & FFRAND))
	+ (void)dobeep_msg("End of buffer");
	+ return(TRUE);
	+ }
	+ if ((lastflag & CFCPCN) == 0) /* Fix goal. */
	+ setgoal();
	+ thisflag \|= CFCPCN;
	+ if (n == 0)
	+ return (TRUE);
	+ while (n--) {
	+ dlp = lforw(dlp);
	+ if (dlp == curbp->b_headp) {
	+ curwp->w_dotp = lback(dlp);
	+ curwp->w_doto = llength(curwp->w_dotp);
	+ curwp->w_rflag \|= WFMOVE;
	+ if (!(f & FFRAND))
	+ (void)dobeep_msg("End of buffer");
	+ return (TRUE);
	+ }
	+ curwp->w_dotline++;
	+ }
	+ curwp->w_rflag \|= WFMOVE;
	+ curwp->w_dotp = dlp;
	+ curwp->w_doto = getgoal(dlp);
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * This function is like "forwline", but
	+ * goes backwards. The scheme is exactly the same.
	+ * Check for arguments that are less than zero and
	+ * call your alternate. Figure out the new line and
	+ * call "movedot" to perform the motion.
	+ */
	+/* ARGSUSED */
	+int
	+backline(int f, int n)
	+{
	+ struct line *dlp;
	+
	+ if (n < 0)
	+ return (forwline(f \| FFRAND, -n));
	+ if ((lastflag & CFCPCN) == 0) /* Fix goal. */
	+ setgoal();
	+ thisflag \|= CFCPCN;
	+ dlp = curwp->w_dotp;
	+ if (lback(dlp) == curbp->b_headp) {
	+ if (!(f & FFRAND))
	+ (void)dobeep_msg("Beginning of buffer");
	+ return(TRUE);
	+ }
	+ while (n-- && lback(dlp) != curbp->b_headp) {
	+ dlp = lback(dlp);
	+ curwp->w_dotline--;
	+ }
	+ if (n > 0 && !(f & FFRAND))
	+ (void)dobeep_msg("Beginning of buffer");
	+ curwp->w_dotp = dlp;
	+ curwp->w_doto = getgoal(dlp);
	+ curwp->w_rflag \|= WFMOVE;
	+ return (TRUE);
	+}
	+
	+/*
	+ * Set the current goal column, which is saved in the external variable
	+ * "curgoal", to the current cursor column. The column is never off
	+ * the edge of the screen; it's more like display then show position.
	+ */
	+void
	+setgoal(void)
	+{
	+ curgoal = getcolpos(curwp); /* Get the position. */
	+ /* we can now display past end of display, don't chop! */
	+}
	+
	+/*
	+ * This routine looks at a line (pointed
	+ * to by the LINE pointer "dlp") and the current
	+ * vertical motion goal column (set by the "setgoal"
	+ * routine above) and returns the best offset to use
	+ * when a vertical motion is made into the line.
	+ */
	+int
	+getgoal(struct line *dlp)
	+{
	+ int c, i, col = 0;
	+ char tmp[5];
	+
	+
	+ for (i = 0; i < llength(dlp); i++) {
	+ c = lgetc(dlp, i);
	+ if (c == '\t'
	+#ifdef NOTAB
	+ && !(curbp->b_flag & BFNOTAB)
	+#endif
	+ ) {
	+ col \|= 0x07;
	+ col++;
	+ } else if (ISCTRL(c) != FALSE) {
	+ col += 2;
	+ } else if (isprint(c))
	+ col++;
	+ else {
	+ col += snprintf(tmp, sizeof(tmp), "\\%o", c);
	+ }
	+ if (col > curgoal)
	+ break;
	+ }
	+ return (i);
	+}
	+
	+/*
	+ * Scroll forward by a specified number
	+ * of lines, or by a full page if no argument.
	+ * The "2" is the window overlap (this is the default
	+ * value from ITS EMACS). Because the top line in
	+ * the window is zapped, we have to do a hard
	+ * update and get it back.
	+ */
	+/* ARGSUSED */
	+int
	+forwpage(int f, int n)
	+{
	+ struct line *lp;
	+
	+ if (!(f & FFARG)) {
	+ n = curwp->w_ntrows - 2; /* Default scroll. */
	+ if (n <= 0) /* Forget the overlap */
	+ n = 1; /* if tiny window. */
	+ } else if (n < 0)
	+ return (backpage(f \| FFRAND, -n));
	+
	+ lp = curwp->w_linep;
	+ while (n--)
	+ if ((lp = lforw(lp)) == curbp->b_headp) {
	+ (void)dobeep_msg("End of buffer");
	+ return(TRUE);
	+ }
	+ curwp->w_linep = lp;
	+ curwp->w_rflag \|= WFFULL;
	+
	+ /* if in current window, don't move dot */
	+ for (n = curwp->w_ntrows; n-- && lp != curbp->b_headp; lp = lforw(lp))
	+ if (lp == curwp->w_dotp)
	+ return (TRUE);
	+
	+ /* Advance the dot the slow way, for line nos */
	+ while (curwp->w_dotp != curwp->w_linep) {
	+ curwp->w_dotp = lforw(curwp->w_dotp);
	+ curwp->w_dotline++;
	+ }
	+ curwp->w_doto = 0;
	+ return (TRUE);
	+}
	+
	+/*
	+ * This command is like "forwpage",
	+ * but it goes backwards. The "2", like above,
	+ * is the overlap between the two windows. The
	+ * value is from the ITS EMACS manual. The
	+ * hard update is done because the top line in
	+ * the window is zapped.
	+ */
	+/* ARGSUSED */
	+int
	+backpage(int f, int n)
	+{
	+ struct line lp, lp2;
	+
	+ if (!(f & FFARG)) {
	+ n = curwp->w_ntrows - 2; /* Default scroll. */
	+ if (n <= 0) /* Don't blow up if the */
	+ return (backline(f, 1));/* window is tiny. */
	+ } else if (n < 0)
	+ return (forwpage(f \| FFRAND, -n));
	+
	+ lp = lp2 = curwp->w_linep;
	+
	+ while (n-- && lback(lp) != curbp->b_headp) {
	+ lp = lback(lp);
	+ }
	+ if (lp == curwp->w_linep)
	+ (void)dobeep_msg("Beginning of buffer");
	+
	+ curwp->w_linep = lp;
	+ curwp->w_rflag \|= WFFULL;
	+
	+ /* if in current window, don't move dot */
	+ for (n = curwp->w_ntrows; n-- && lp != curbp->b_headp; lp = lforw(lp))
	+ if (lp == curwp->w_dotp)
	+ return (TRUE);
	+
	+ lp2 = lforw(lp2);
	+
	+ /* Move the dot the slow way, for line nos */
	+ while (curwp->w_dotp != lp2) {
	+ if (curwp->w_dotline <= curwp->w_ntrows)
	+ goto out;
	+ curwp->w_dotp = lback(curwp->w_dotp);
	+ curwp->w_dotline--;
	+ }
	+out:
	+ curwp->w_doto = 0;
	+ return (TRUE);
	+}
	+
	+/*
	+ * These functions are provided for compatibility with Gosling's Emacs. They
	+ * are used to scroll the display up (or down) one line at a time.
	+ */
	+int
	+forw1page(int f, int n)
	+{
	+ if (!(f & FFARG)) {
	+ n = 1;
	+ f = FFUNIV;
	+ }
	+ forwpage(f \| FFRAND, n);
	+ return (TRUE);
	+}
	+
	+int
	+back1page(int f, int n)
	+{
	+ if (!(f & FFARG)) {
	+ n = 1;
	+ f = FFUNIV;
	+ }
	+ backpage(f \| FFRAND, n);
	+ return (TRUE);
	+}
	+
	+/*
	+ * Page the other window. Check to make sure it exists, then
	+ * nextwind, forwpage and restore window pointers.
	+ */
	+int
	+pagenext(int f, int n)
	+{
	+ struct mgwin *wp;
	+
	+ if (wheadp->w_wndp == NULL)
	+ return(dobeep_msg("No other window"));
	+
	+ wp = curwp;
	+ (void) nextwind(f, n);
	+ (void) forwpage(f, n);
	+ curwp = wp;
	+ curbp = wp->w_bufp;
	+ return (TRUE);
	+}
	+
	+/*
	+ * Internal set mark routine, used by other functions (daveb).
	+ */
	+void
	+isetmark(void)
	+{
	+ curwp->w_markp = curwp->w_dotp;
	+ curwp->w_marko = curwp->w_doto;
	+ curwp->w_markline = curwp->w_dotline;
	+}
	+
	+/*
	+ * Set the mark in the current window
	+ * to the value of dot. A message is written to
	+ * the echo line. (ewprintf knows about macros)
	+ */
	+/* ARGSUSED */
	+int
	+setmark(int f, int n)
	+{
	+ isetmark();
	+ ewprintf("Mark set");
	+ return (TRUE);
	+}
	+
	+/* Clear the mark, if set. */
	+/* ARGSUSED */
	+int
	+clearmark(int f, int n)
	+{
	+ if (!curwp->w_markp)
	+ return (FALSE);
	+
	+ curwp->w_markp = NULL;
	+ curwp->w_marko = 0;
	+ curwp->w_markline = 0;
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * Swap the values of "dot" and "mark" in
	+ * the current window. This is pretty easy, because
	+ * all of the hard work gets done by the standard routine
	+ * that moves the mark about. The only possible
	+ * error is "no mark".
	+ */
	+/* ARGSUSED */
	+int
	+swapmark(int f, int n)
	+{
	+ struct line *odotp;
	+ int odoto, odotline;
	+
	+ if (curwp->w_markp == NULL)
	+ return(dobeep_msg("No mark in this window"));
	+
	+ odotp = curwp->w_dotp;
	+ odoto = curwp->w_doto;
	+ odotline = curwp->w_dotline;
	+ curwp->w_dotp = curwp->w_markp;
	+ curwp->w_doto = curwp->w_marko;
	+ curwp->w_dotline = curwp->w_markline;
	+ curwp->w_markp = odotp;
	+ curwp->w_marko = odoto;
	+ curwp->w_markline = odotline;
	+ curwp->w_rflag \|= WFMOVE;
	+ return (TRUE);
	+}
	+
	+/*
	+ * Go to a specific line, mostly for
	+ * looking up errors in C programs, which give the
	+ * error a line number. If an argument is present, then
	+ * it is the line number, else prompt for a line number
	+ * to use.
	+ */
	+/* ARGSUSED */
	+int
	+gotoline(int f, int n)
	+{
	+ char buf[32], *bufp;
	+ const char *err;
	+
	+ if (!(f & FFARG)) {
	+ if ((bufp = eread("Goto line: ", buf, sizeof(buf),
	+ EFNUL \| EFNEW \| EFCR)) == NULL)
	+ return (ABORT);
	+ if (bufp[0] == '\0')
	+ return (ABORT);
	+ n = (int)strtonum(buf, INT_MIN, INT_MAX, &err);
	+ if (err)
	+ return(dobeep_msgs("Line number %s", err));
	+ }
	+ return(setlineno(n));
	+}
	+
	+/*
	+ * Set the line number and switch to it.
	+ */
	+int
	+setlineno(int n)
	+{
	+ struct line *clp;
	+
	+ if (n >= 0) {
	+ if (n == 0)
	+ n++;
	+ curwp->w_dotline = n;
	+ clp = lforw(curbp->b_headp); /* "clp" is first line */
	+ while (--n > 0) {
	+ if (lforw(clp) == curbp->b_headp) {
	+ curwp->w_dotline = curwp->w_bufp->b_lines;
	+ break;
	+ }
	+ clp = lforw(clp);
	+ }
	+ } else {
	+ curwp->w_dotline = curwp->w_bufp->b_lines + n;
	+ clp = lback(curbp->b_headp); /* "clp" is last line */
	+ while (n < 0) {
	+ if (lback(clp) == curbp->b_headp) {
	+ curwp->w_dotline = 1;
	+ break;
	+ }
	+ clp = lback(clp);
	+ n++;
	+ }
	+ }
	+ curwp->w_dotp = clp;
	+ curwp->w_doto = 0;
	+ curwp->w_rflag \|= WFMOVE;
	+ return (TRUE);
	+}
	Index: contrib/mg/bell.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/bell.c
	@@ -0,0 +1,90 @@
	+/* $OpenBSD: bell.c,v 1.6 2021/05/06 12:44:21 lum Exp $ */
	+
	+/*
	+ * This file is in the public domain.
	+ *
	+ * Author: Mark Lumsden <mark@showcomplex.com>
	+ *
	+ */
	+
	+/*
	+ * Control how mg communicates with the user.
	+ */
	+
	+#include <sys/queue.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <unistd.h>
	+
	+#include "def.h"
	+#include "macro.h"
	+
	+void
	+bellinit(void)
	+{
	+ doaudiblebell = 1;
	+ dovisiblebell = 0;
	+}
	+
	+int
	+dobeep_num(const char *msg, int n)
	+{
	+ ewprintf("%s %d", msg, n);
	+ dobeep();
	+ return (FALSE);
	+}
	+
	+int
	+dobeep_msgs(const char msg, const char s)
	+{
	+ ewprintf("%s %s", msg, s);
	+ dobeep();
	+ return (FALSE);
	+}
	+
	+int
	+dobeep_msg(const char *msg)
	+{
	+ ewprintf("%s", msg);
	+ dobeep();
	+ return (FALSE);
	+}
	+
	+void
	+dobeep(void)
	+{
	+ if (doaudiblebell) {
	+ ttbeep();
	+ }
	+ if (dovisiblebell) {
	+ sgarbf = TRUE;
	+ update(CNONE);
	+ if (inmacro) /* avoid delaying macro execution. */
	+ return;
	+ usleep(50000);
	+ }
	+}
	+
	+/* ARGSUSED */
	+int
	+toggleaudiblebell(int f, int n)
	+{
	+ if (f & FFARG)
	+ doaudiblebell = n > 0;
	+ else
	+ doaudiblebell = !doaudiblebell;
	+
	+ return (TRUE);
	+}
	+
	+/* ARGSUSED */
	+int
	+togglevisiblebell(int f, int n)
	+{
	+ if (f & FFARG)
	+ dovisiblebell = n > 0;
	+ else
	+ dovisiblebell = !dovisiblebell;
	+
	+ return (TRUE);
	+}
	Index: contrib/mg/buffer.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/buffer.c
	@@ -0,0 +1,1070 @@
	+/* $OpenBSD: buffer.c,v 1.112 2021/03/26 15:02:10 lum Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * Buffer handling.
	+ */
	+
	+#include <sys/queue.h>
	+#include <errno.h>
	+#include <libgen.h>
	+#include <signal.h>
	+#include <stdarg.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+#include <unistd.h>
	+
	+#include "def.h"
	+#include "kbd.h" /* needed for modes */
	+
	+#define DIFFTOOL "/usr/bin/diff"
	+
	+static struct buffer *makelist(void);
	+static struct buffer bnew(const char );
	+
	+static int usebufname(const char *);
	+
	+/* Flag for global working dir */
	+extern int globalwd;
	+
	+/* ARGSUSED */
	+int
	+togglereadonlyall(int f, int n)
	+{
	+ struct buffer *bp = NULL;
	+ int len = 0;
	+
	+ allbro = !allbro;
	+ for (bp = bheadp; bp != NULL; bp = bp->b_bufp) {
	+ len = strlen(bp->b_bname);
	+ if (bp->b_bname[0] != '' && bp->b_bname[len - 1] != '') {
	+ if (allbro)
	+ bp->b_flag \|= BFREADONLY;
	+ else
	+ bp->b_flag &= ~BFREADONLY;
	+ }
	+ }
	+ curwp->w_rflag \|= WFMODE;
	+
	+ return (TRUE);
	+}
	+
	+/* ARGSUSED */
	+int
	+togglereadonly(int f, int n)
	+{
	+ int s;
	+
	+ if ((s = checkdirty(curbp)) != TRUE)
	+ return (s);
	+ if (!(curbp->b_flag & BFREADONLY))
	+ curbp->b_flag \|= BFREADONLY;
	+ else {
	+ curbp->b_flag &= ~BFREADONLY;
	+ if (curbp->b_flag & BFCHG)
	+ ewprintf("Warning: Buffer was modified");
	+ }
	+ curwp->w_rflag \|= WFMODE;
	+
	+ return (TRUE);
	+}
	+
	+/* Switch to the named buffer.
	+ * If no name supplied, switch to the default (alternate) buffer.
	+ */
	+int
	+usebufname(const char *bufp)
	+{
	+ struct buffer *bp = NULL;
	+ int ret;
	+
	+ if (bufp == NULL) {
	+ if ((bp = bfind("scratch", TRUE)) == NULL)
	+ return(FALSE);
	+ } else if (bufp[0] == '\0' && curbp->b_altb != NULL)
	+ bp = curbp->b_altb;
	+ else if ((bp = bfind(bufp, TRUE)) == NULL)
	+ return (FALSE);
	+
	+ /* and put it in current window */
	+ curbp = bp;
	+ ret = showbuffer(bp, curwp, WFFRAME \| WFFULL);
	+ eerase();
	+
	+ return (ret);
	+}
	+
	+/*
	+ * Attach a buffer to a window. The values of dot and mark come
	+ * from the buffer if the use count is 0. Otherwise, they come
	+ * from some other window. scratch is the default alternate
	+ * buffer.
	+ */
	+/* ARGSUSED */
	+int
	+usebuffer(int f, int n)
	+{
	+ char bufn[NBUFN], *bufp;
	+
	+ /* Get buffer to use from user */
	+ if (curbp->b_altb == NULL)
	+ bufp = eread("Switch to buffer: ", bufn, NBUFN, EFNEW \| EFBUF);
	+ else
	+ bufp = eread("Switch to buffer (default %s): ", bufn, NBUFN,
	+ EFNUL \| EFNEW \| EFBUF, curbp->b_altb->b_bname);
	+
	+ if (bufp == NULL)
	+ return (ABORT);
	+
	+ return (usebufname(bufp));
	+}
	+
	+/*
	+ * pop to buffer asked for by the user.
	+ */
	+/* ARGSUSED */
	+int
	+poptobuffer(int f, int n)
	+{
	+ struct buffer *bp;
	+ struct mgwin *wp;
	+ char bufn[NBUFN], *bufp;
	+
	+ /* Get buffer to use from user */
	+ if ((curbp->b_altb == NULL) &&
	+ ((curbp->b_altb = bfind("scratch", TRUE)) == NULL))
	+ bufp = eread("Switch to buffer in other window: ", bufn, NBUFN,
	+ EFNEW \| EFBUF);
	+ else
	+ bufp = eread("Switch to buffer in other window (default %s): ",
	+ bufn, NBUFN, EFNUL \| EFNEW \| EFBUF, curbp->b_altb->b_bname);
	+ if (bufp == NULL)
	+ return (ABORT);
	+ if (bufp[0] == '\0' && curbp->b_altb != NULL)
	+ bp = curbp->b_altb;
	+ else if ((bp = bfind(bufp, TRUE)) == NULL)
	+ return (FALSE);
	+ if (bp == curbp)
	+ return (splitwind(f, n));
	+ /* and put it in a new, non-ephemeral window */
	+ if ((wp = popbuf(bp, WNONE)) == NULL)
	+ return (FALSE);
	+ curbp = bp;
	+ curwp = wp;
	+ return (TRUE);
	+}
	+
	+/*
	+ * Dispose of a buffer, by name.
	+ * Ask for the name (unless called by dired mode). Look it up (don't
	+ * get too upset if it isn't there at all!). Clear the buffer (ask
	+ * if the buffer has been changed). Then free the header
	+ * line and the buffer header. Bound to "C-x k".
	+ */
	+/* ARGSUSED */
	+int
	+killbuffer_cmd(int f, int n)
	+{
	+ struct buffer *bp;
	+ char bufn[NBUFN], *bufp;
	+ int ret;
	+
	+ if (f & FFRAND) /* dired mode 'q' */
	+ bp = curbp;
	+ else if ((bufp = eread("Kill buffer (default %s): ", bufn, NBUFN,
	+ EFNUL \| EFNEW \| EFBUF, curbp->b_bname)) == NULL)
	+ return (ABORT);
	+ else if (bufp[0] == '\0')
	+ bp = curbp;
	+ else if ((bp = bfind(bufp, FALSE)) == NULL)
	+ return (FALSE);
	+ ret = killbuffer(bp);
	+ eerase();
	+
	+ return (ret);
	+}
	+
	+int
	+killbuffer(struct buffer *bp)
	+{
	+ struct buffer *bp1;
	+ struct buffer *bp2;
	+ struct mgwin *wp;
	+ int s;
	+ struct undo_rec *rec;
	+
	+ /*
	+ * Find some other buffer to display. Try the alternate buffer,
	+ * then the first different buffer in the buffer list. If there's
	+ * only one buffer, create buffer scratch and make it the alternate
	+ * buffer. Return if scratch is only buffer...
	+ */
	+ if ((bp1 = bp->b_altb) == NULL) {
	+ /* only one buffer. see if it's scratch */
	+ if (bp == bfind("scratch", FALSE))
	+ return (TRUE);
	+ /* create scratch for alternate buffer */
	+ if ((bp1 = bfind("scratch", TRUE)) == NULL)
	+ return (FALSE);
	+ }
	+ if ((s = bclear(bp)) != TRUE)
	+ return (s);
	+ for (wp = wheadp; bp->b_nwnd > 0; wp = wp->w_wndp) {
	+ if (wp->w_bufp == bp) {
	+ bp2 = bp1->b_altb; /* save alternate buffer */
	+ if (showbuffer(bp1, wp, WFMODE \| WFFRAME \| WFFULL))
	+ bp1->b_altb = bp2;
	+ else
	+ bp1 = bp2;
	+ }
	+ }
	+ if (bp == curbp)
	+ curbp = bp1;
	+ free(bp->b_headp); /* Release header line. */
	+ bp2 = NULL; /* Find the header. */
	+ bp1 = bheadp;
	+ while (bp1 != bp) {
	+ if (bp1->b_altb == bp)
	+ bp1->b_altb = (bp->b_altb == bp1) ? NULL : bp->b_altb;
	+ bp2 = bp1;
	+ bp1 = bp1->b_bufp;
	+ }
	+ bp1 = bp1->b_bufp; /* Next one in chain. */
	+ if (bp2 == NULL) /* Unlink it. */
	+ bheadp = bp1;
	+ else
	+ bp2->b_bufp = bp1;
	+ while (bp1 != NULL) { /* Finish with altb's */
	+ if (bp1->b_altb == bp)
	+ bp1->b_altb = (bp->b_altb == bp1) ? NULL : bp->b_altb;
	+ bp1 = bp1->b_bufp;
	+ }
	+
	+ while ((rec = TAILQ_FIRST(&bp->b_undo))) {
	+ TAILQ_REMOVE(&bp->b_undo, rec, next);
	+ free_undo_record(rec);
	+ }
	+
	+ free(bp->b_bname); /* Release name block */
	+ free(bp); /* Release buffer block */
	+ return (TRUE);
	+}
	+
	+/*
	+ * Save some buffers - just call anycb with the arg flag.
	+ */
	+/* ARGSUSED */
	+int
	+savebuffers(int f, int n)
	+{
	+ if (anycb(f) == ABORT)
	+ return (ABORT);
	+ return (TRUE);
	+}
	+
	+/*
	+ * Listing buffers.
	+ */
	+static int listbuf_ncol;
	+
	+static int listbuf_goto_buffer(int f, int n);
	+static int listbuf_goto_buffer_one(int f, int n);
	+static int listbuf_goto_buffer_helper(int f, int n, int only);
	+
	+static PF listbuf_pf[] = {
	+ listbuf_goto_buffer
	+};
	+static PF listbuf_one[] = {
	+ listbuf_goto_buffer_one
	+};
	+
	+
	+static struct KEYMAPE (2) listbufmap = {
	+ 2,
	+ 2,
	+ rescan,
	+ {
	+ {
	+ CCHR('M'), CCHR('M'), listbuf_pf, NULL
	+ },
	+ {
	+ '1', '1', listbuf_one, NULL
	+ }
	+ }
	+};
	+
	+/*
	+ * Display the buffer list. This is done
	+ * in two parts. The "makelist" routine figures out
	+ * the text, and puts it in a buffer. "popbuf"
	+ * then pops the data onto the screen. Bound to
	+ * "C-x C-b".
	+ */
	+/* ARGSUSED */
	+int
	+listbuffers(int f, int n)
	+{
	+ static int initialized = 0;
	+ struct buffer *bp;
	+ struct mgwin *wp;
	+
	+ if (!initialized) {
	+ maps_add((KEYMAP *)&listbufmap, "listbufmap");
	+ initialized = 1;
	+ }
	+
	+ if ((bp = makelist()) == NULL \|\| (wp = popbuf(bp, WNONE)) == NULL)
	+ return (FALSE);
	+ wp->w_dotp = bp->b_dotp; /* fix up if window already on screen */
	+ wp->w_doto = bp->b_doto;
	+ bp->b_modes[0] = name_mode("fundamental");
	+ bp->b_modes[1] = name_mode("listbufmap");
	+ bp->b_nmodes = 1;
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * This routine rebuilds the text for the
	+ * list buffers command. Return pointer
	+ * to new list if everything works.
	+ * Return NULL if there is an error (if
	+ * there is no memory).
	+ */
	+static struct buffer *
	+makelist(void)
	+{
	+ int w = ncol / 2;
	+ struct buffer bp, blp;
	+ struct line *lp;
	+
	+ if ((blp = bfind("Buffer List", TRUE)) == NULL)
	+ return (NULL);
	+ if (bclear(blp) != TRUE)
	+ return (NULL);
	+ blp->b_flag &= ~BFCHG; /* Blow away old. */
	+ blp->b_flag \|= BFREADONLY;
	+
	+ listbuf_ncol = ncol; /* cache ncol for listbuf_goto_buffer */
	+
	+ if (addlinef(blp, "%-*s%s", w, " MR Buffer", "Size File") == FALSE \|\|
	+ addlinef(blp, "%-*s%s", w, " -- ------", "---- ----") == FALSE)
	+ return (NULL);
	+
	+ for (bp = bheadp; bp != NULL; bp = bp->b_bufp) {
	+ RSIZE nbytes;
	+
	+ nbytes = 0; /* Count bytes in buf. */
	+ if (bp != blp) {
	+ lp = bfirstlp(bp);
	+ while (lp != bp->b_headp) {
	+ nbytes += llength(lp) + 1;
	+ lp = lforw(lp);
	+ }
	+ if (nbytes)
	+ nbytes--; /* no bonus newline */
	+ }
	+
	+ if (addlinef(blp, "%c%c%c %-.s%c%-6d %-*s",
	+ (bp == curbp) ? '>' : ' ', /* current buffer ? */
	+ ((bp->b_flag & BFCHG) != 0) ? '' : ' ', / changed ? */
	+ ((bp->b_flag & BFREADONLY) != 0) ? '*' : ' ',
	+ w - 5, /* four chars already written */
	+ w - 5, /* four chars already written */
	+ bp->b_bname, /* buffer name */
	+ strlen(bp->b_bname) < w - 5 ? ' ' : '$', /* truncated? */
	+ nbytes, /* buffer size */
	+ w - 7, /* seven chars already written */
	+ bp->b_fname) == FALSE)
	+ return (NULL);
	+ }
	+ blp->b_dotp = bfirstlp(blp); /* put dot at beginning of
	+ * buffer */
	+ blp->b_doto = 0;
	+ return (blp); /* All done */
	+}
	+
	+static int
	+listbuf_goto_buffer(int f, int n)
	+{
	+ return (listbuf_goto_buffer_helper(f, n, 0));
	+}
	+
	+static int
	+listbuf_goto_buffer_one(int f, int n)
	+{
	+ return (listbuf_goto_buffer_helper(f, n, 1));
	+}
	+
	+static int
	+listbuf_goto_buffer_helper(int f, int n, int only)
	+{
	+ struct buffer *bp;
	+ struct mgwin *wp;
	+ char *line = NULL;
	+ int i, ret = FALSE;
	+
	+ if (curwp->w_dotp->l_text[listbuf_ncol/2 - 1] == '$')
	+ return(dobeep_msg("buffer name truncated"));
	+
	+ if ((line = malloc(listbuf_ncol/2)) == NULL)
	+ return (FALSE);
	+
	+ memcpy(line, curwp->w_dotp->l_text + 4, listbuf_ncol/2 - 5);
	+ for (i = listbuf_ncol/2 - 6; i > 0; i--) {
	+ if (line[i] != ' ') {
	+ line[i + 1] = '\0';
	+ break;
	+ }
	+ }
	+ if (i == 0)
	+ goto cleanup;
	+
	+ for (bp = bheadp; bp != NULL; bp = bp->b_bufp) {
	+ if (strcmp(bp->b_bname, line) == 0)
	+ break;
	+ }
	+ if (bp == NULL)
	+ goto cleanup;
	+
	+ if ((wp = popbuf(bp, WNONE)) == NULL)
	+ goto cleanup;
	+ curbp = bp;
	+ curwp = wp;
	+
	+ if (only)
	+ ret = (onlywind(FFRAND, 1));
	+ else
	+ ret = TRUE;
	+
	+cleanup:
	+ free(line);
	+
	+ return (ret);
	+}
	+
	+/*
	+ * The argument "fmt" points to a format string. Append this line to the
	+ * buffer. Handcraft the EOL on the end. Return TRUE if it worked and
	+ * FALSE if you ran out of room.
	+ */
	+int
	+addlinef(struct buffer bp, char fmt, ...)
	+{
	+ va_list ap;
	+ struct line *lp;
	+
	+ if ((lp = lalloc(0)) == NULL)
	+ return (FALSE);
	+ va_start(ap, fmt);
	+ if (vasprintf(&lp->l_text, fmt, ap) == -1) {
	+ lfree(lp);
	+ va_end(ap);
	+ return (FALSE);
	+ }
	+ lp->l_used = strlen(lp->l_text);
	+ va_end(ap);
	+
	+ bp->b_headp->l_bp->l_fp = lp; /* Hook onto the end */
	+ lp->l_bp = bp->b_headp->l_bp;
	+ bp->b_headp->l_bp = lp;
	+ lp->l_fp = bp->b_headp;
	+ bp->b_lines++;
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * Look through the list of buffers, giving the user a chance to save them.
	+ * Return TRUE if there are any changed buffers afterwards. Buffers that don't
	+ * have an associated file don't count. Return FALSE if there are no changed
	+ * buffers. Return ABORT if an error occurs or if the user presses c-g.
	+ */
	+int
	+anycb(int f)
	+{
	+ struct buffer *bp;
	+ int s = FALSE, save = FALSE, save2 = FALSE, ret;
	+ char pbuf[NFILEN + 11];
	+
	+ for (bp = bheadp; bp != NULL; bp = bp->b_bufp) {
	+ if (*(bp->b_fname) != '\0' && (bp->b_flag & BFCHG) != 0) {
	+ ret = snprintf(pbuf, sizeof(pbuf), "Save file %s",
	+ bp->b_fname);
	+ if (ret < 0 \|\| ret >= sizeof(pbuf)) {
	+ (void)dobeep_msg("Error: filename too long!");
	+ return (UERROR);
	+ }
	+ if ((f == TRUE \|\| (save = eyorn(pbuf)) == TRUE) &&
	+ (save2 = buffsave(bp)) == TRUE) {
	+ bp->b_flag &= ~BFCHG;
	+ upmodes(bp);
	+ } else {
	+ if (save2 == FIOERR)
	+ return (save2);
	+ s = TRUE;
	+ }
	+ if (save == ABORT)
	+ return (save);
	+ save = TRUE;
	+ }
	+ }
	+ if (save == FALSE /* && kbdmop == NULL / ) / experimental */
	+ ewprintf("(No files need saving)");
	+ return (s);
	+}
	+
	+/*
	+ * Search for a buffer, by name.
	+ * If not found, and the "cflag" is TRUE,
	+ * create a new buffer. Return pointer to the found
	+ * (or new) buffer.
	+ */
	+struct buffer *
	+bfind(const char *bname, int cflag)
	+{
	+ struct buffer *bp;
	+
	+ bp = bheadp;
	+ while (bp != NULL) {
	+ if (strcmp(bname, bp->b_bname) == 0)
	+ return (bp);
	+ bp = bp->b_bufp;
	+ }
	+ if (cflag != TRUE)
	+ return (NULL);
	+
	+ bp = bnew(bname);
	+
	+ return (bp);
	+}
	+
	+/*
	+ * Create a new buffer and put it in the list of
	+ * all buffers.
	+ */
	+static struct buffer *
	+bnew(const char *bname)
	+{
	+ struct buffer *bp;
	+ struct line *lp;
	+ int i;
	+ size_t len;
	+
	+ bp = calloc(1, sizeof(struct buffer));
	+ if (bp == NULL) {
	+ dobeep();
	+ ewprintf("Can't get %d bytes", sizeof(struct buffer));
	+ return (NULL);
	+ }
	+ if ((lp = lalloc(0)) == NULL) {
	+ free(bp);
	+ return (NULL);
	+ }
	+ bp->b_altb = bp->b_bufp = NULL;
	+ bp->b_dotp = lp;
	+ bp->b_doto = 0;
	+ bp->b_markp = NULL;
	+ bp->b_marko = 0;
	+ bp->b_flag = defb_flag;
	+ /* if buffer name starts and ends with '', we ignore changes /
	+ len = strlen(bname);
	+ if (len) {
	+ if (bname[0] == '' && bname[len - 1] == '')
	+ bp->b_flag \|= BFIGNDIRTY;
	+ }
	+ bp->b_nwnd = 0;
	+ bp->b_headp = lp;
	+ bp->b_nmodes = defb_nmodes;
	+ TAILQ_INIT(&bp->b_undo);
	+ bp->b_undoptr = NULL;
	+ i = 0;
	+ do {
	+ bp->b_modes[i] = defb_modes[i];
	+ } while (i++ < defb_nmodes);
	+ bp->b_fname[0] = '\0';
	+ bp->b_cwd[0] = '\0';
	+ bzero(&bp->b_fi, sizeof(bp->b_fi));
	+ lp->l_fp = lp;
	+ lp->l_bp = lp;
	+ bp->b_bufp = bheadp;
	+ bheadp = bp;
	+ bp->b_dotline = bp->b_markline = 1;
	+ bp->b_lines = 1;
	+ bp->b_nlseq = "\n"; /* use unix default */
	+ bp->b_nlchr = bp->b_nlseq;
	+ if ((bp->b_bname = strdup(bname)) == NULL) {
	+ dobeep();
	+ ewprintf("Can't get %d bytes", strlen(bname) + 1);
	+ return (NULL);
	+ }
	+
	+ return (bp);
	+}
	+
	+/*
	+ * This routine blows away all of the text
	+ * in a buffer. If the buffer is marked as changed
	+ * then we ask if it is ok to blow it away; this is
	+ * to save the user the grief of losing text. The
	+ * window chain is nearly always wrong if this gets
	+ * called; the caller must arrange for the updates
	+ * that are required. Return TRUE if everything
	+ * looks good.
	+ */
	+int
	+bclear(struct buffer *bp)
	+{
	+ struct line *lp;
	+ int s;
	+
	+ /* Has buffer changed, and do we care? */
	+ if (!(bp->b_flag & BFIGNDIRTY) && (bp->b_flag & BFCHG) != 0 &&
	+ (s = eyesno("Buffer modified; kill anyway")) != TRUE)
	+ return (s);
	+ bp->b_flag &= ~BFCHG; /* Not changed */
	+ while ((lp = lforw(bp->b_headp)) != bp->b_headp)
	+ lfree(lp);
	+ bp->b_dotp = bp->b_headp; /* Fix dot */
	+ bp->b_doto = 0;
	+ bp->b_markp = NULL; /* Invalidate "mark" */
	+ bp->b_marko = 0;
	+ bp->b_dotline = bp->b_markline = 1;
	+ bp->b_lines = 1;
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * Display the given buffer in the given window. Flags indicated
	+ * action on redisplay. Update modified flag so insert loop can check it.
	+ */
	+int
	+showbuffer(struct buffer bp, struct mgwin wp, int flags)
	+{
	+ struct buffer *obp;
	+ struct mgwin *owp;
	+
	+ /* Ensure file has not been modified elsewhere */
	+ if (fchecktime(bp) != TRUE)
	+ bp->b_flag \|= BFDIRTY;
	+
	+ if (wp->w_bufp == bp) { /* Easy case! */
	+ wp->w_rflag \|= flags;
	+ return (TRUE);
	+ }
	+ /* First, detach the old buffer from the window */
	+ if ((bp->b_altb = obp = wp->w_bufp) != NULL) {
	+ if (--obp->b_nwnd == 0) {
	+ obp->b_dotp = wp->w_dotp;
	+ obp->b_doto = wp->w_doto;
	+ obp->b_markp = wp->w_markp;
	+ obp->b_marko = wp->w_marko;
	+ obp->b_dotline = wp->w_dotline;
	+ obp->b_markline = wp->w_markline;
	+ }
	+ }
	+ /* Now, attach the new buffer to the window */
	+ wp->w_bufp = bp;
	+
	+ if (bp->b_nwnd++ == 0) { /* First use. */
	+ wp->w_dotp = bp->b_dotp;
	+ wp->w_doto = bp->b_doto;
	+ wp->w_markp = bp->b_markp;
	+ wp->w_marko = bp->b_marko;
	+ wp->w_dotline = bp->b_dotline;
	+ wp->w_markline = bp->b_markline;
	+ } else
	+ /* already on screen, steal values from other window */
	+ for (owp = wheadp; owp != NULL; owp = wp->w_wndp)
	+ if (wp->w_bufp == bp && owp != wp) {
	+ wp->w_dotp = owp->w_dotp;
	+ wp->w_doto = owp->w_doto;
	+ wp->w_markp = owp->w_markp;
	+ wp->w_marko = owp->w_marko;
	+ wp->w_dotline = owp->w_dotline;
	+ wp->w_markline = owp->w_markline;
	+ break;
	+ }
	+ wp->w_rflag \|= WFMODE \| flags;
	+ return (TRUE);
	+}
	+
	+/*
	+ * Augment a buffer name with a number, if necessary
	+ *
	+ * If more than one file of the same basename() is open,
	+ * the additional buffers are named "file<2>", "file<3>", and
	+ * so forth. This function adjusts a buffer name to
	+ * include the number, if necessary.
	+ */
	+int
	+augbname(char bn, const char fn, size_t bs)
	+{
	+ int count;
	+ size_t remain, len;
	+
	+ if ((len = xbasename(bn, fn, bs)) >= bs)
	+ return (FALSE);
	+
	+ remain = bs - len;
	+ for (count = 2; bfind(bn, FALSE) != NULL; count++)
	+ snprintf(bn + len, remain, "<%d>", count);
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * Pop the buffer we got passed onto the screen.
	+ * Returns a status.
	+ */
	+struct mgwin *
	+popbuf(struct buffer *bp, int flags)
	+{
	+ struct mgwin *wp;
	+
	+ if (bp->b_nwnd == 0) { /* Not on screen yet. */
	+ /*
	+ * Pick a window for a pop-up.
	+ * If only one window, split the screen.
	+ * Flag the new window as ephemeral
	+ */
	+ if (wheadp->w_wndp == NULL &&
	+ splitwind(FFOTHARG, flags) == FALSE)
	+ return (NULL);
	+
	+ /*
	+ * Pick the uppermost window that isn't
	+ * the current window. An LRU algorithm
	+ * might be better. Return a pointer, or NULL on error.
	+ */
	+ wp = wheadp;
	+
	+ while (wp != NULL && wp == curwp)
	+ wp = wp->w_wndp;
	+ } else {
	+ for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
	+ if (wp->w_bufp == bp) {
	+ wp->w_rflag \|= WFFULL \| WFFRAME;
	+ return (wp);
	+ }
	+ }
	+ }
	+ if (!wp)
	+ return (NULL);
	+
	+ if (showbuffer(bp, wp, WFFULL) != TRUE)
	+ return (NULL);
	+ return (wp);
	+}
	+
	+/*
	+ * Insert another buffer at dot. Very useful.
	+ */
	+/* ARGSUSED */
	+int
	+bufferinsert(int f, int n)
	+{
	+ struct buffer *bp;
	+ struct line *clp;
	+ int clo, nline;
	+ char bufn[NBUFN], *bufp;
	+
	+ /* Get buffer to use from user */
	+ if (curbp->b_altb != NULL)
	+ bufp = eread("Insert buffer (default %s): ", bufn, NBUFN,
	+ EFNUL \| EFNEW \| EFBUF, curbp->b_altb->b_bname);
	+ else
	+ bufp = eread("Insert buffer: ", bufn, NBUFN, EFNEW \| EFBUF);
	+ if (bufp == NULL)
	+ return (ABORT);
	+ if (bufp[0] == '\0' && curbp->b_altb != NULL)
	+ bp = curbp->b_altb;
	+ else if ((bp = bfind(bufp, FALSE)) == NULL)
	+ return (FALSE);
	+
	+ if (bp == curbp)
	+ return(dobeep_msg("Cannot insert buffer into self"));
	+
	+ /* insert the buffer */
	+ nline = 0;
	+ clp = bfirstlp(bp);
	+ for (;;) {
	+ for (clo = 0; clo < llength(clp); clo++)
	+ if (linsert(1, lgetc(clp, clo)) == FALSE)
	+ return (FALSE);
	+ if ((clp = lforw(clp)) == bp->b_headp)
	+ break;
	+ if (enewline(FFRAND, 1) == FALSE) /* fake newline */
	+ return (FALSE);
	+ nline++;
	+ }
	+ if (nline == 1)
	+ ewprintf("[Inserted 1 line]");
	+ else
	+ ewprintf("[Inserted %d lines]", nline);
	+
	+ clp = curwp->w_linep; /* cosmetic adjustment */
	+ if (curwp->w_dotp == clp) { /* for offscreen insert */
	+ while (nline-- && lback(clp) != curbp->b_headp)
	+ clp = lback(clp);
	+ curwp->w_linep = clp; /* adjust framing. */
	+ curwp->w_rflag \|= WFFULL;
	+ }
	+ return (TRUE);
	+}
	+
	+/*
	+ * Turn off the dirty bit on this buffer.
	+ */
	+/* ARGSUSED */
	+int
	+notmodified(int f, int n)
	+{
	+ struct mgwin *wp;
	+
	+ curbp->b_flag &= ~BFCHG;
	+ wp = wheadp; /* Update mode lines. */
	+ while (wp != NULL) {
	+ if (wp->w_bufp == curbp)
	+ wp->w_rflag \|= WFMODE;
	+ wp = wp->w_wndp;
	+ }
	+ ewprintf("Modification-flag cleared");
	+ return (TRUE);
	+}
	+
	+/*
	+ * Popbuf and set all windows to top of buffer.
	+ */
	+int
	+popbuftop(struct buffer *bp, int flags)
	+{
	+ struct mgwin *wp;
	+
	+ bp->b_dotp = bfirstlp(bp);
	+ bp->b_doto = 0;
	+ if (bp->b_nwnd != 0) {
	+ for (wp = wheadp; wp != NULL; wp = wp->w_wndp)
	+ if (wp->w_bufp == bp) {
	+ wp->w_dotp = bp->b_dotp;
	+ wp->w_doto = 0;
	+ wp->w_rflag \|= WFFULL;
	+ }
	+ }
	+ return (popbuf(bp, flags) != NULL);
	+}
	+
	+/*
	+ * Return the working directory for the current buffer, terminated
	+ * with a '/'. First, try to extract it from the current buffer's
	+ * filename. If that fails, use global cwd.
	+ */
	+int
	+getbufcwd(char *path, size_t plen)
	+{
	+ char cwd[NFILEN];
	+
	+ if (plen == 0)
	+ return (FALSE);
	+
	+ if (globalwd == FALSE && curbp->b_cwd[0] != '\0') {
	+ (void)strlcpy(path, curbp->b_cwd, plen);
	+ } else {
	+ if (getcwdir(cwd, sizeof(cwd)) == FALSE)
	+ goto error;
	+ (void)strlcpy(path, cwd, plen);
	+ }
	+ return (TRUE);
	+error:
	+ path[0] = '\0';
	+ return (FALSE);
	+}
	+
	+/*
	+ * Ensures a buffer has not been modified elsewhere; e.g. on disk.
	+ * Prompt the user if it has.
	+ * Returns TRUE if it has NOT (i.e. buffer is ok to edit).
	+ * FALSE or ABORT otherwise
	+ */
	+int
	+checkdirty(struct buffer *bp)
	+{
	+ int s;
	+
	+ if ((bp->b_flag & (BFCHG \| BFDIRTY)) == 0)
	+ if (fchecktime(bp) != TRUE)
	+ bp->b_flag \|= BFDIRTY;
	+
	+ if ((bp->b_flag & (BFDIRTY \| BFIGNDIRTY)) == BFDIRTY) {
	+ s = eynorr("File changed on disk; really edit the buffer");
	+ switch (s) {
	+ case TRUE:
	+ bp->b_flag &= ~BFDIRTY;
	+ bp->b_flag \|= BFIGNDIRTY;
	+ return (TRUE);
	+ case REVERT:
	+ dorevert();
	+ return (FALSE);
	+ default:
	+ return (s);
	+ }
	+ }
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * Revert the current buffer to whatever is on disk.
	+ */
	+/* ARGSUSED */
	+int
	+revertbuffer(int f, int n)
	+{
	+ char fbuf[NFILEN + 32];
	+
	+ if (curbp->b_fname[0] == 0)
	+ return(dobeep_msg("Cannot revert buffer not associated "
	+ "with any files."));
	+
	+ snprintf(fbuf, sizeof(fbuf), "Revert buffer from file %s",
	+ curbp->b_fname);
	+
	+ if (eyorn(fbuf) == TRUE)
	+ return dorevert();
	+
	+ return (FALSE);
	+}
	+
	+int
	+dorevert(void)
	+{
	+ int lineno;
	+ struct undo_rec *rec;
	+
	+ if (access(curbp->b_fname, F_OK\|R_OK) != 0) {
	+ dobeep();
	+ if (errno == ENOENT)
	+ ewprintf("File %s no longer exists!",
	+ curbp->b_fname);
	+ else
	+ ewprintf("File %s is no longer readable!",
	+ curbp->b_fname);
	+ return (FALSE);
	+ }
	+
	+ /* Save our current line, so we can go back after reloading. */
	+ lineno = curwp->w_dotline;
	+
	+ /* Prevent readin from asking if we want to kill the buffer. */
	+ curbp->b_flag &= ~BFCHG;
	+
	+ /* Clean up undo memory */
	+ while ((rec = TAILQ_FIRST(&curbp->b_undo))) {
	+ TAILQ_REMOVE(&curbp->b_undo, rec, next);
	+ free_undo_record(rec);
	+ }
	+
	+ if (readin(curbp->b_fname))
	+ return(setlineno(lineno));
	+ return (FALSE);
	+}
	+
	+/*
	+ * Diff the current buffer to what is on disk.
	+ */
	+/ARGSUSED /
	+int
	+diffbuffer(int f, int n)
	+{
	+ struct buffer *bp;
	+ struct line lp, lpend;
	+ size_t len;
	+ int ret;
	+ char text, ttext;
	+ char * const argv[] =
	+ {DIFFTOOL, "-u", "-p", curbp->b_fname, "-", (char *)NULL};
	+
	+ len = 0;
	+
	+ /* C-u is not supported */
	+ if (n > 1)
	+ return (ABORT);
	+
	+ if (access(DIFFTOOL, X_OK) != 0) {
	+ dobeep();
	+ ewprintf("%s not found or not executable.", DIFFTOOL);
	+ return (FALSE);
	+ }
	+
	+ if (curbp->b_fname[0] == 0)
	+ return(dobeep_msg("Cannot diff buffer not associated with "
	+ "any files."));
	+
	+ lpend = curbp->b_headp;
	+ for (lp = lforw(lpend); lp != lpend; lp = lforw(lp)) {
	+ len+=llength(lp);
	+ if (lforw(lp) != lpend) /* no implied \n on last line */
	+ len++;
	+ }
	+ if ((text = calloc(len + 1, sizeof(char))) == NULL)
	+ return(dobeep_msg("Cannot allocate memory."));
	+
	+ ttext = text;
	+
	+ for (lp = lforw(lpend); lp != lpend; lp = lforw(lp)) {
	+ if (llength(lp) != 0) {
	+ memcpy(ttext, ltext(lp), llength(lp));
	+ ttext += llength(lp);
	+ }
	+ if (lforw(lp) != lpend) /* no implied \n on last line */
	+ ttext++ = curbp->b_nlchr;
	+ }
	+
	+ bp = bfind("Diff", TRUE);
	+ bp->b_flag \|= BFREADONLY;
	+ if (bclear(bp) != TRUE) {
	+ free(text);
	+ return (FALSE);
	+ }
	+
	+ ret = pipeio(DIFFTOOL, argv, text, len, bp);
	+
	+ if (ret == TRUE) {
	+ eerase();
	+ if (lforw(bp->b_headp) == bp->b_headp)
	+ addline(bp, "Diff finished (no differences).");
	+ }
	+
	+ free(text);
	+ return (ret);
	+}
	+
	+/*
	+ * Given a file name, either find the buffer it uses, or create a new
	+ * empty buffer to put it in.
	+ */
	+struct buffer *
	+findbuffer(char *fn)
	+{
	+ struct buffer *bp;
	+ char bname[NBUFN], fname[NBUFN];
	+
	+ if (strlcpy(fname, fn, sizeof(fname)) >= sizeof(fname)) {
	+ (void)dobeep_msg("filename too long");
	+ return (NULL);
	+ }
	+
	+ for (bp = bheadp; bp != NULL; bp = bp->b_bufp) {
	+ if (strcmp(bp->b_fname, fname) == 0)
	+ return (bp);
	+ }
	+ /* Not found. Create a new one, adjusting name first */
	+ if (augbname(bname, fname, sizeof(bname)) == FALSE)
	+ return (NULL);
	+
	+ bp = bfind(bname, TRUE);
	+ return (bp);
	+}
	Index: contrib/mg/cdbr.h
	===================================================================
	--- /dev/null
	+++ contrib/mg/cdbr.h
	@@ -0,0 +1,64 @@
	+/* $NetBSD: cdbr.h,v 1.1 2013/12/11 01:24:08 joerg Exp $ */
	+/*-
	+ * Copyright (c) 2010 The NetBSD Foundation, Inc.
	+ * All rights reserved.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Joerg Sonnenberger.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ *
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in
	+ * the documentation and/or other materials provided with the
	+ * distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
	+ * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
	+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
	+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	+ * SUCH DAMAGE.
	+ */
	+
	+#ifndef _CDBR_H
	+#define _CDBR_H
	+
	+#include <sys/cdefs.h>
	+#if defined(_KERNEL) \|\| defined(_STANDALONE)
	+#include <sys/types.h>
	+#else
	+#include <inttypes.h>
	+#include <stddef.h>
	+#endif
	+
	+#define CDBR_DEFAULT 0
	+
	+struct cdbr;
	+
	+__BEGIN_DECLS
	+
	+#if !defined(_KERNEL) && !defined(_STANDALONE)
	+struct cdbr cdbr_open(const char , int);
	+#endif
	+struct cdbr cdbr_open_mem(void , size_t, int,
	+ void ()(void , void , size_t), void );
	+uint32_t cdbr_entries(struct cdbr *);
	+int cdbr_get(struct cdbr , uint32_t, const void , size_t );
	+int cdbr_find(struct cdbr , const void , size_t,
	+ const void *, size_t );
	+void cdbr_close(struct cdbr *);
	+
	+__END_DECLS
	+
	+#endif /* _CDBR_H */
	Index: contrib/mg/cdbr.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/cdbr.c
	@@ -0,0 +1,294 @@
	+/* $NetBSD: cdbr.c,v 1.2 2017/01/10 23:06:06 christos Exp $ */
	+/*-
	+ * Copyright (c) 2010 The NetBSD Foundation, Inc.
	+ * All rights reserved.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Joerg Sonnenberger.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ *
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in
	+ * the documentation and/or other materials provided with the
	+ * distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
	+ * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
	+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
	+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	+ * SUCH DAMAGE.
	+ */
	+
	+#include <sys/cdefs.h>
	+#include <sys/mman.h>
	+#include <sys/stat.h>
	+
	+#include <errno.h>
	+#include <fcntl.h>
	+#include <inttypes.h>
	+#include <limits.h>
	+#include <stdlib.h>
	+#include <string.h>
	+#include <unistd.h>
	+
	+#include "cdbr.h"
	+
	+#define SET_ERRNO(val) errno = (val)
	+
	+#ifndef fast_divide32_prepare
	+#define fast_divide32_prepare(d,m,s1,s2) (void)0
	+#endif
	+
	+#ifndef fast_remainder32
	+#define fast_remainder32(v,d,m,s1,s2) (v%d)
	+#endif
	+
	+extern void mi_vector_hash(const void * __restrict, size_t, uint32_t,
	+ uint32_t[3]);
	+
	+struct cdbr {
	+ void (unmap)(void , void *, size_t);
	+ void *cookie;
	+ uint8_t *mmap_base;
	+ size_t mmap_size;
	+
	+ uint8_t *hash_base;
	+ uint8_t *offset_base;
	+ uint8_t *data_base;
	+
	+ uint32_t data_size;
	+ uint32_t entries;
	+ uint32_t entries_index;
	+ uint32_t seed;
	+
	+ uint8_t offset_size;
	+ uint8_t index_size;
	+
	+ uint32_t entries_m;
	+ uint32_t entries_index_m;
	+ uint8_t entries_s1, entries_s2;
	+ uint8_t entries_index_s1, entries_index_s2;
	+};
	+
	+/* From NetBSD sys/external/bsd/libnv/dist/nv_compat.h */
	+static uint32_t
	+le32dec(const void *buf)
	+{
	+ uint8_t const p = (uint8_t const ) buf;
	+
	+ return (((unsigned) p[3] << 24) \| (p[2] << 16) \| (p[1] << 8) \| p[0]);
	+}
	+
	+#if !defined(_KERNEL) && !defined(_STANDALONE)
	+static void
	+cdbr_unmap(void cookie __unused, void base, size_t size)
	+{
	+ munmap(base, size);
	+}
	+
	+/* ARGSUSED */
	+struct cdbr *
	+cdbr_open(const char *path, int flags)
	+{
	+ void *base;
	+ size_t size;
	+ int fd;
	+ struct cdbr *cdbr;
	+ struct stat sb;
	+
	+ if ((fd = open(path, O_RDONLY)) == -1)
	+ return NULL;
	+ if (fstat(fd, &sb) == -1) {
	+ close(fd);
	+ return NULL;
	+ }
	+
	+ if (sb.st_size >= SSIZE_MAX) {
	+ close(fd);
	+ SET_ERRNO(EINVAL);
	+ return NULL;
	+ }
	+
	+
	+ size = (size_t)sb.st_size;
	+ base = mmap(NULL, size, PROT_READ, MAP_FILE\|MAP_SHARED, fd, 0);
	+ close(fd);
	+
	+ if (base == MAP_FAILED)
	+ return NULL;
	+
	+ cdbr = cdbr_open_mem(base, size, flags, cdbr_unmap, NULL);
	+ if (cdbr == NULL)
	+ munmap(base, size);
	+ return cdbr;
	+}
	+#endif
	+
	+struct cdbr *
	+cdbr_open_mem(void *base, size_t size, int flags __unused,
	+ void (unmap)(void , void , size_t), void cookie)
	+{
	+ struct cdbr *cdbr;
	+ uint8_t *buf = base;
	+ if (size < 40 \|\| memcmp(buf, "NBCDB\n\0\001", 8)) {
	+ SET_ERRNO(EINVAL);
	+ return NULL;
	+ }
	+
	+ cdbr = malloc(sizeof(*cdbr));
	+ cdbr->unmap = unmap;
	+ cdbr->cookie = cookie;
	+
	+ cdbr->data_size = le32dec(buf + 24);
	+ cdbr->entries = le32dec(buf + 28);
	+ cdbr->entries_index = le32dec(buf + 32);
	+ cdbr->seed = le32dec(buf + 36);
	+
	+ if (cdbr->data_size < 0x100)
	+ cdbr->offset_size = 1;
	+ else if (cdbr->data_size < 0x10000)
	+ cdbr->offset_size = 2;
	+ else
	+ cdbr->offset_size = 4;
	+
	+ if (cdbr->entries_index < 0x100)
	+ cdbr->index_size = 1;
	+ else if (cdbr->entries_index < 0x10000)
	+ cdbr->index_size = 2;
	+ else
	+ cdbr->index_size = 4;
	+
	+ cdbr->mmap_base = base;
	+ cdbr->mmap_size = size;
	+
	+ cdbr->hash_base = cdbr->mmap_base + 40;
	+ cdbr->offset_base = cdbr->hash_base + cdbr->entries_index * cdbr->index_size;
	+ if (cdbr->entries_index * cdbr->index_size % cdbr->offset_size)
	+ cdbr->offset_base += cdbr->offset_size -
	+ cdbr->entries_index * cdbr->index_size % cdbr->offset_size;
	+ cdbr->data_base = cdbr->offset_base + (cdbr->entries + 1) * cdbr->offset_size;
	+
	+ if (cdbr->hash_base < cdbr->mmap_base \|\|
	+ cdbr->offset_base < cdbr->mmap_base \|\|
	+ cdbr->data_base < cdbr->mmap_base \|\|
	+ cdbr->data_base + cdbr->data_size < cdbr->mmap_base \|\|
	+ cdbr->data_base + cdbr->data_size >
	+ cdbr->mmap_base + cdbr->mmap_size) {
	+ SET_ERRNO(EINVAL);
	+ free(cdbr);
	+ return NULL;
	+ }
	+
	+ if (cdbr->entries) {
	+ fast_divide32_prepare(cdbr->entries, &cdbr->entries_m,
	+ &cdbr->entries_s1, &cdbr->entries_s2);
	+ }
	+ if (cdbr->entries_index) {
	+ fast_divide32_prepare(cdbr->entries_index,
	+ &cdbr->entries_index_m,
	+ &cdbr->entries_index_s1, &cdbr->entries_index_s2);
	+ }
	+
	+ return cdbr;
	+}
	+
	+static uint32_t
	+get_uintX(const uint8_t *addr, uint32_t idx, int size)
	+{
	+ addr += idx * size;
	+
	+ if (size == 4)
	+ return /* LINTED /le32toh((const uint32_t *)addr);
	+ else if (size == 2)
	+ return /* LINTED /le16toh((const uint16_t *)addr);
	+ else
	+ return *addr;
	+}
	+
	+uint32_t
	+cdbr_entries(struct cdbr *cdbr)
	+{
	+
	+ return cdbr->entries;
	+}
	+
	+int
	+cdbr_get(struct cdbr cdbr, uint32_t idx, const void data, size_t data_len)
	+{
	+ uint32_t start, end;
	+
	+ if (idx >= cdbr->entries) {
	+ SET_ERRNO(EINVAL);
	+ return -1;
	+ }
	+
	+ start = get_uintX(cdbr->offset_base, idx, cdbr->offset_size);
	+ end = get_uintX(cdbr->offset_base, idx + 1, cdbr->offset_size);
	+
	+ if (start > end) {
	+ SET_ERRNO(EIO);
	+ return -1;
	+ }
	+
	+ if (end > cdbr->data_size) {
	+ SET_ERRNO(EIO);
	+ return -1;
	+ }
	+
	+ *data = cdbr->data_base + start;
	+ *data_len = end - start;
	+
	+ return 0;
	+}
	+
	+int
	+cdbr_find(struct cdbr cdbr, const void key, size_t key_len,
	+ const void *data, size_t data_len)
	+{
	+ uint32_t hashes[3], idx;
	+
	+ if (cdbr->entries_index == 0) {
	+ SET_ERRNO(EINVAL);
	+ return -1;
	+ }
	+
	+ mi_vector_hash(key, key_len, cdbr->seed, hashes);
	+
	+ hashes[0] = fast_remainder32(hashes[0], cdbr->entries_index,
	+ cdbr->entries_index_m, cdbr->entries_index_s1,
	+ cdbr->entries_index_s2);
	+ hashes[1] = fast_remainder32(hashes[1], cdbr->entries_index,
	+ cdbr->entries_index_m, cdbr->entries_index_s1,
	+ cdbr->entries_index_s2);
	+ hashes[2] = fast_remainder32(hashes[2], cdbr->entries_index,
	+ cdbr->entries_index_m, cdbr->entries_index_s1,
	+ cdbr->entries_index_s2);
	+
	+ idx = get_uintX(cdbr->hash_base, hashes[0], cdbr->index_size);
	+ idx += get_uintX(cdbr->hash_base, hashes[1], cdbr->index_size);
	+ idx += get_uintX(cdbr->hash_base, hashes[2], cdbr->index_size);
	+
	+ return cdbr_get(cdbr, fast_remainder32(idx, cdbr->entries,
	+ cdbr->entries_m, cdbr->entries_s1, cdbr->entries_s2), data,
	+ data_len);
	+}
	+
	+void
	+cdbr_close(struct cdbr *cdbr)
	+{
	+ if (cdbr->unmap)
	+ (*cdbr->unmap)(cdbr->cookie, cdbr->mmap_base, cdbr->mmap_size);
	+ free(cdbr);
	+}
	Index: contrib/mg/cdbw.h
	===================================================================
	--- /dev/null
	+++ contrib/mg/cdbw.h
	@@ -0,0 +1,55 @@
	+/* $NetBSD: cdbw.h,v 1.2 2012/06/03 21:21:45 joerg Exp $ */
	+/*-
	+ * Copyright (c) 2010 The NetBSD Foundation, Inc.
	+ * All rights reserved.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Joerg Sonnenberger.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ *
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in
	+ * the documentation and/or other materials provided with the
	+ * distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
	+ * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
	+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
	+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	+ * SUCH DAMAGE.
	+ */
	+
	+#ifndef _CDBW_H
	+#define _CDBW_H
	+
	+#include <sys/cdefs.h>
	+#include <inttypes.h>
	+#include <stddef.h>
	+
	+struct cdbw;
	+
	+struct cdbw *cdbw_open(void);
	+int cdbw_put(struct cdbw , const void , size_t,
	+ const void *, size_t);
	+int cdbw_put_data(struct cdbw , const void , size_t,
	+ uint32_t *);
	+int cdbw_put_key(struct cdbw , const void , size_t,
	+ uint32_t);
	+uint32_t cdbw_stable_seeder(void);
	+int cdbw_output(struct cdbw *, int, const char[16],
	+ uint32_t (*)(void));
	+void cdbw_close(struct cdbw *);
	+
	+#endif /* _CDBW_H */
	Index: contrib/mg/cdbw.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/cdbw.c
	@@ -0,0 +1,578 @@
	+/* $NetBSD: cdbw.c,v 1.6 2017/11/11 18:05:31 alnsn Exp $ */
	+/*-
	+ * Copyright (c) 2009, 2010, 2015 The NetBSD Foundation, Inc.
	+ * All rights reserved.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Joerg Sonnenberger and Alexander Nasonov.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ *
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in
	+ * the documentation and/or other materials provided with the
	+ * distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
	+ * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
	+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
	+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	+ * SUCH DAMAGE.
	+ */
	+
	+#include <sys/cdefs.h>
	+#include <sys/queue.h>
	+
	+#include <stdlib.h>
	+#include <string.h>
	+#include <unistd.h>
	+
	+#include "cdbw.h"
	+
	+void le32enc(void *, uint32_t);
	+void mi_vector_hash(const void * __restrict, size_t, uint32_t,
	+ uint32_t[3]);
	+
	+struct key_hash {
	+ SLIST_ENTRY(key_hash) link;
	+ uint32_t hashes[3];
	+ uint32_t idx;
	+ void *key;
	+ size_t keylen;
	+};
	+
	+SLIST_HEAD(key_hash_head, key_hash);
	+
	+struct cdbw {
	+ size_t data_counter;
	+ size_t data_allocated;
	+ size_t data_size;
	+ size_t *data_len;
	+ void **data_ptr;
	+
	+ size_t hash_size;
	+ struct key_hash_head *hash;
	+ size_t key_counter;
	+};
	+
	+ /* Max. data counter that allows the index size to be 32bit. */
	+static const uint32_t max_data_counter = 0xccccccccU;
	+
	+struct cdbw *
	+cdbw_open(void)
	+{
	+ struct cdbw *cdbw;
	+ size_t i;
	+
	+ cdbw = calloc(sizeof(*cdbw), 1);
	+ if (cdbw == NULL)
	+ return NULL;
	+
	+ cdbw->hash_size = 1024;
	+ cdbw->hash = calloc(cdbw->hash_size, sizeof(*cdbw->hash));
	+ if (cdbw->hash == NULL) {
	+ free(cdbw);
	+ return NULL;
	+ }
	+
	+ for (i = 0; i < cdbw->hash_size; ++i)
	+ SLIST_INIT(cdbw->hash + i);
	+
	+ return cdbw;
	+}
	+
	+int
	+cdbw_put(struct cdbw cdbw, const void key, size_t keylen,
	+ const void *data, size_t datalen)
	+{
	+ uint32_t idx;
	+ int rv;
	+
	+ rv = cdbw_put_data(cdbw, data, datalen, &idx);
	+ if (rv)
	+ return rv;
	+ rv = cdbw_put_key(cdbw, key, keylen, idx);
	+ if (rv) {
	+ --cdbw->data_counter;
	+ free(cdbw->data_ptr[cdbw->data_counter]);
	+ cdbw->data_size -= datalen;
	+ return rv;
	+ }
	+ return 0;
	+}
	+
	+int
	+cdbw_put_data(struct cdbw cdbw, const void data, size_t datalen,
	+ uint32_t *idx)
	+{
	+
	+ if (cdbw->data_counter == max_data_counter)
	+ return -1;
	+
	+ if (cdbw->data_size + datalen < cdbw->data_size \|\|
	+ cdbw->data_size + datalen > 0xffffffffU)
	+ return -1; /* Overflow */
	+
	+ if (cdbw->data_allocated == cdbw->data_counter) {
	+ void **new_data_ptr;
	+ size_t *new_data_len;
	+ size_t new_allocated;
	+
	+ if (cdbw->data_allocated == 0)
	+ new_allocated = 256;
	+ else
	+ new_allocated = cdbw->data_allocated * 2;
	+
	+ new_data_ptr = realloc(cdbw->data_ptr,
	+ sizeof(cdbw->data_ptr) new_allocated);
	+ if (new_data_ptr == NULL)
	+ return -1;
	+ cdbw->data_ptr = new_data_ptr;
	+
	+ new_data_len = realloc(cdbw->data_len,
	+ sizeof(cdbw->data_len) new_allocated);
	+ if (new_data_len == NULL)
	+ return -1;
	+ cdbw->data_len = new_data_len;
	+
	+ cdbw->data_allocated = new_allocated;
	+ }
	+
	+ cdbw->data_ptr[cdbw->data_counter] = malloc(datalen);
	+ if (cdbw->data_ptr[cdbw->data_counter] == NULL)
	+ return -1;
	+ memcpy(cdbw->data_ptr[cdbw->data_counter], data, datalen);
	+ cdbw->data_len[cdbw->data_counter] = datalen;
	+ cdbw->data_size += datalen;
	+ *idx = cdbw->data_counter++;
	+ return 0;
	+}
	+
	+int
	+cdbw_put_key(struct cdbw cdbw, const void key, size_t keylen, uint32_t idx)
	+{
	+ uint32_t hashes[3];
	+ struct key_hash_head head, head2, *new_head;
	+ struct key_hash *key_hash;
	+ size_t new_hash_size, i;
	+
	+ if (idx >= cdbw->data_counter \|\|
	+ cdbw->key_counter == max_data_counter)
	+ return -1;
	+
	+ mi_vector_hash(key, keylen, 0, hashes);
	+
	+ head = cdbw->hash + (hashes[0] & (cdbw->hash_size - 1));
	+ SLIST_FOREACH(key_hash, head, link) {
	+ if (key_hash->keylen != keylen)
	+ continue;
	+ if (key_hash->hashes[0] != hashes[0])
	+ continue;
	+ if (key_hash->hashes[1] != hashes[1])
	+ continue;
	+ if (key_hash->hashes[2] != hashes[2])
	+ continue;
	+ if (memcmp(key, key_hash->key, keylen))
	+ continue;
	+ return -1;
	+ }
	+ key_hash = malloc(sizeof(*key_hash));
	+ if (key_hash == NULL)
	+ return -1;
	+ key_hash->key = malloc(keylen);
	+ if (key_hash->key == NULL) {
	+ free(key_hash);
	+ return -1;
	+ }
	+ memcpy(key_hash->key, key, keylen);
	+ key_hash->hashes[0] = hashes[0];
	+ key_hash->hashes[1] = hashes[1];
	+ key_hash->hashes[2] = hashes[2];
	+ key_hash->keylen = keylen;
	+ key_hash->idx = idx;
	+ SLIST_INSERT_HEAD(head, key_hash, link);
	+ ++cdbw->key_counter;
	+
	+ if (cdbw->key_counter <= cdbw->hash_size)
	+ return 0;
	+
	+ /* Try to resize the hash table, but ignore errors. */
	+ new_hash_size = cdbw->hash_size * 2;
	+ new_head = calloc(sizeof(*new_head), new_hash_size);
	+ if (new_head == NULL)
	+ return 0;
	+
	+ head = &cdbw->hash[hashes[0] & (cdbw->hash_size - 1)];
	+ for (i = 0; i < new_hash_size; ++i)
	+ SLIST_INIT(new_head + i);
	+
	+ for (i = 0; i < cdbw->hash_size; ++i) {
	+ head = cdbw->hash + i;
	+
	+ while ((key_hash = SLIST_FIRST(head)) != NULL) {
	+ SLIST_REMOVE_HEAD(head, link);
	+ head2 = new_head +
	+ (key_hash->hashes[0] & (new_hash_size - 1));
	+ SLIST_INSERT_HEAD(head2, key_hash, link);
	+ }
	+ }
	+ free(cdbw->hash);
	+ cdbw->hash_size = new_hash_size;
	+ cdbw->hash = new_head;
	+
	+ return 0;
	+}
	+
	+void
	+cdbw_close(struct cdbw *cdbw)
	+{
	+ struct key_hash_head *head;
	+ struct key_hash *key_hash;
	+ size_t i;
	+
	+ for (i = 0; i < cdbw->hash_size; ++i) {
	+ head = cdbw->hash + i;
	+ while ((key_hash = SLIST_FIRST(head)) != NULL) {
	+ SLIST_REMOVE_HEAD(head, link);
	+ free(key_hash->key);
	+ free(key_hash);
	+ }
	+ }
	+
	+ for (i = 0; i < cdbw->data_counter; ++i)
	+ free(cdbw->data_ptr[i]);
	+ free(cdbw->data_ptr);
	+ free(cdbw->data_len);
	+ free(cdbw->hash);
	+ free(cdbw);
	+}
	+
	+uint32_t
	+cdbw_stable_seeder(void)
	+{
	+ return 0;
	+}
	+
	+/*
	+ * The algorithm below is based on paper
	+ * Cache-Oblivious Peeling of Random Hypergraphs by Djamal Belazzougui,
	+ * Paolo Boldi, Giuseppe Ottaviano, Rossano Venturini, and Sebastiano
	+ * Vigna.
	+ * http://zola.di.unipi.it/rossano/wp-content/papercite-data/pdf/dcc14.pdf
	+ */
	+
	+/*
	+ * Data type for a valid oriented edge (v0, v1, v2), v1 < v2.
	+ * The first vertex v0 is implicit and is determined by an index
	+ * of the corresponding element in the state->oedges array.
	+ * If the degree of v0 is greater than 1, other members don't
	+ * make sense because they're a result of XORing multiple values.
	+ */
	+struct oedge {
	+ uint32_t degree; /* Degree of v0. */
	+ uint32_t verts[2]; /* v1 and v2 */
	+ uint32_t edge;
	+};
	+
	+struct edge {
	+ uint32_t idx;
	+
	+ uint32_t left, middle, right;
	+};
	+
	+struct state {
	+ uint32_t data_entries;
	+ uint32_t entries;
	+ uint32_t keys;
	+ uint32_t seed;
	+
	+ uint32_t *g;
	+ char *visited;
	+
	+ struct oedge *oedges;
	+ struct edge *edges;
	+ uint32_t output_index;
	+ uint32_t *output_order;
	+};
	+
	+/*
	+ * Add (delta == 1) or remove (delta == -1) the edge e from vertex v0.
	+ */
	+static void
	+add_remove_edge(struct oedge *o, int delta, uint32_t e,
	+ uint32_t v0, uint32_t v1, uint32_t v2)
	+{
	+
	+ o[v0].verts[v1 < v2 ? 0 : 1] ^= v1;
	+ o[v0].verts[v1 < v2 ? 1 : 0] ^= v2;
	+ o[v0].degree += delta;
	+ o[v0].edge ^= e;
	+}
	+
	+static void
	+add_edge(struct oedge *o, uint32_t e,
	+ uint32_t v0, uint32_t v1, uint32_t v2)
	+{
	+
	+ add_remove_edge(o, 1, e, v0, v1, v2);
	+}
	+
	+static void
	+remove_vertex(struct state *state, uint32_t v0)
	+{
	+ uint32_t e, v1, v2;
	+ struct oedge *o = state->oedges;
	+
	+ if (o[v0].degree == 1) {
	+ e = o[v0].edge;
	+ v1 = o[v0].verts[0];
	+ v2 = o[v0].verts[1];
	+ o[v0].degree = 0;
	+ add_remove_edge(o, -1, e, v1, v0, v2);
	+ add_remove_edge(o, -1, e, v2, v0, v1);
	+ state->output_order[--state->output_index] = e;
	+ }
	+}
	+
	+static int
	+build_graph(struct cdbw cdbw, struct state state)
	+{
	+ struct key_hash_head *head;
	+ struct key_hash *key_hash;
	+ struct edge *e;
	+ uint32_t hashes[3];
	+ size_t i;
	+
	+ memset(state->oedges, 0, sizeof(struct oedge) * state->entries);
	+
	+ e = state->edges;
	+ for (i = 0; i < cdbw->hash_size; ++i) {
	+ head = &cdbw->hash[i];
	+ SLIST_FOREACH(key_hash, head, link) {
	+ e->idx = key_hash->idx;
	+ mi_vector_hash(key_hash->key, key_hash->keylen,
	+ state->seed, hashes);
	+ e->left = hashes[0] % state->entries;
	+ e->middle = hashes[1] % state->entries;
	+ e->right = hashes[2] % state->entries;
	+
	+ if (e->left == e->middle)
	+ return -1;
	+ add_edge(state->oedges, e - state->edges,
	+ e->right, e->left, e->middle);
	+ if (e->left == e->right)
	+ return -1;
	+ add_edge(state->oedges, e - state->edges,
	+ e->middle, e->left, e->right);
	+ if (e->middle == e->right)
	+ return -1;
	+ add_edge(state->oedges, e - state->edges,
	+ e->left, e->middle, e->right);
	+
	+ ++e;
	+ }
	+ }
	+
	+ state->output_index = state->keys;
	+ for (i = 0; i < state->entries; ++i)
	+ remove_vertex(state, i);
	+
	+ i = state->keys;
	+ while (i > 0 && i > state->output_index) {
	+ --i;
	+ e = state->edges + state->output_order[i];
	+ remove_vertex(state, e->left);
	+ remove_vertex(state, e->middle);
	+ remove_vertex(state, e->right);
	+ }
	+
	+ return state->output_index == 0 ? 0 : -1;
	+}
	+
	+static void
	+assign_nodes(struct state *state)
	+{
	+ struct edge *e;
	+ size_t i;
	+
	+ for (i = 0; i < state->keys; ++i) {
	+ e = state->edges + state->output_order[i];
	+
	+ if (!state->visited[e->left]) {
	+ state->g[e->left] =
	+ (2 * state->data_entries + e->idx
	+ - state->g[e->middle] - state->g[e->right])
	+ % state->data_entries;
	+ } else if (!state->visited[e->middle]) {
	+ state->g[e->middle] =
	+ (2 * state->data_entries + e->idx
	+ - state->g[e->left] - state->g[e->right])
	+ % state->data_entries;
	+ } else {
	+ state->g[e->right] =
	+ (2 * state->data_entries + e->idx
	+ - state->g[e->left] - state->g[e->middle])
	+ % state->data_entries;
	+ }
	+ state->visited[e->left] = 1;
	+ state->visited[e->middle] = 1;
	+ state->visited[e->right] = 1;
	+ }
	+}
	+
	+static size_t
	+compute_size(uint32_t size)
	+{
	+ if (size < 0x100)
	+ return 1;
	+ else if (size < 0x10000)
	+ return 2;
	+ else
	+ return 4;
	+}
	+
	+#define COND_FLUSH_BUFFER(n) do { \
	+ if (__predict_false(cur_pos + (n) >= sizeof(buf))) { \
	+ ret = write(fd, buf, cur_pos); \
	+ if (ret == -1 \|\| (size_t)ret != cur_pos) \
	+ return -1; \
	+ cur_pos = 0; \
	+ } \
	+} while (/* CONSTCOND */ 0)
	+
	+static int
	+print_hash(struct cdbw cdbw, struct state state, int fd, const char *descr)
	+{
	+ uint32_t data_size;
	+ uint8_t buf[90000];
	+ size_t i, size, size2, cur_pos;
	+ ssize_t ret;
	+
	+ memcpy(buf, "NBCDB\n\0", 7);
	+ buf[7] = 1;
	+ strncpy((char *)buf + 8, descr, 16);
	+ le32enc(buf + 24, cdbw->data_size);
	+ le32enc(buf + 28, cdbw->data_counter);
	+ le32enc(buf + 32, state->entries);
	+ le32enc(buf + 36, state->seed);
	+ cur_pos = 40;
	+
	+ size = compute_size(state->entries);
	+ for (i = 0; i < state->entries; ++i) {
	+ COND_FLUSH_BUFFER(4);
	+ le32enc(buf + cur_pos, state->g[i]);
	+ cur_pos += size;
	+ }
	+ size2 = compute_size(cdbw->data_size);
	+ size = size * state->entries % size2;
	+ if (size != 0) {
	+ size = size2 - size;
	+ COND_FLUSH_BUFFER(4);
	+ le32enc(buf + cur_pos, 0);
	+ cur_pos += size;
	+ }
	+ for (data_size = 0, i = 0; i < cdbw->data_counter; ++i) {
	+ COND_FLUSH_BUFFER(4);
	+ le32enc(buf + cur_pos, data_size);
	+ cur_pos += size2;
	+ data_size += cdbw->data_len[i];
	+ }
	+ COND_FLUSH_BUFFER(4);
	+ le32enc(buf + cur_pos, data_size);
	+ cur_pos += size2;
	+
	+ for (i = 0; i < cdbw->data_counter; ++i) {
	+ COND_FLUSH_BUFFER(cdbw->data_len[i]);
	+ if (cdbw->data_len[i] < sizeof(buf)) {
	+ memcpy(buf + cur_pos, cdbw->data_ptr[i],
	+ cdbw->data_len[i]);
	+ cur_pos += cdbw->data_len[i];
	+ } else {
	+ ret = write(fd, cdbw->data_ptr[i], cdbw->data_len[i]);
	+ if (ret == -1 \|\| (size_t)ret != cdbw->data_len[i])
	+ return -1;
	+ }
	+ }
	+ if (cur_pos != 0) {
	+ ret = write(fd, buf, cur_pos);
	+ if (ret == -1 \|\| (size_t)ret != cur_pos)
	+ return -1;
	+ }
	+ return 0;
	+}
	+
	+int
	+cdbw_output(struct cdbw *cdbw, int fd, const char descr[16],
	+ uint32_t (*seedgen)(void))
	+{
	+ struct state state;
	+ int rv;
	+
	+ if (cdbw->data_counter == 0 \|\| cdbw->key_counter == 0) {
	+ state.entries = 0;
	+ state.seed = 0;
	+ print_hash(cdbw, &state, fd, descr);
	+ return 0;
	+ }
	+
	+#if HAVE_NBTOOL_CONFIG_H
	+ if (seedgen == NULL)
	+ seedgen = cdbw_stable_seeder;
	+#else
	+ if (seedgen == NULL)
	+ seedgen = arc4random;
	+#endif
	+
	+ rv = 0;
	+
	+ state.keys = cdbw->key_counter;
	+ state.data_entries = cdbw->data_counter;
	+ state.entries = state.keys + (state.keys + 3) / 4;
	+ if (state.entries < 10)
	+ state.entries = 10;
	+
	+#define NALLOC(var, n) var = calloc(sizeof(*var), n)
	+ NALLOC(state.g, state.entries);
	+ NALLOC(state.visited, state.entries);
	+ NALLOC(state.oedges, state.entries);
	+ NALLOC(state.edges, state.keys);
	+ NALLOC(state.output_order, state.keys);
	+#undef NALLOC
	+
	+ if (state.g == NULL \|\| state.visited == NULL \|\| state.oedges == NULL \|\|
	+ state.edges == NULL \|\| state.output_order == NULL) {
	+ rv = -1;
	+ goto release;
	+ }
	+
	+ state.seed = 0;
	+ do {
	+ if (seedgen == cdbw_stable_seeder)
	+ ++state.seed;
	+ else
	+ state.seed = (*seedgen)();
	+ } while (build_graph(cdbw, &state));
	+
	+ assign_nodes(&state);
	+ rv = print_hash(cdbw, &state, fd, descr);
	+
	+release:
	+ free(state.g);
	+ free(state.visited);
	+ free(state.oedges);
	+ free(state.edges);
	+ free(state.output_order);
	+
	+ return rv;
	+}
	Index: contrib/mg/chrdef.h
	===================================================================
	--- /dev/null
	+++ contrib/mg/chrdef.h
	@@ -0,0 +1,74 @@
	+/* $OpenBSD: chrdef.h,v 1.10 2015/03/25 12:29:03 bcallah Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * sys/default/chardef.h: character set specific #defines for Mg 2a
	+ * Warning: System specific ones exist
	+ */
	+
	+/*
	+ * Casting should be at least as efficient as anding with 0xff,
	+ * and won't have the size problems.
	+ */
	+#define CHARMASK(c) ((unsigned char) (c))
	+
	+/*
	+ * These flags, and the macros below them,
	+ * make up a do-it-yourself set of "ctype" macros that
	+ * understand the DEC multinational set, and let me ask
	+ * a slightly different set of questions.
	+ */
	+#define _MG_W 0x01 /* Word. */
	+#define _MG_U 0x02 /* Upper case letter. */
	+#define _MG_L 0x04 /* Lower case letter. */
	+#define _MG_C 0x08 /* Control. */
	+#define _MG_P 0x10 /* end of sentence punctuation */
	+#define _MG_D 0x20 /* is decimal digit */
	+
	+#define ISWORD(c) ((cinfo[CHARMASK(c)]&_MG_W)!=0)
	+#define ISCTRL(c) ((cinfo[CHARMASK(c)]&_MG_C)!=0)
	+#define ISUPPER(c) ((cinfo[CHARMASK(c)]&_MG_U)!=0)
	+#define ISLOWER(c) ((cinfo[CHARMASK(c)]&_MG_L)!=0)
	+#define ISEOSP(c) ((cinfo[CHARMASK(c)]&_MG_P)!=0)
	+#define ISDIGIT(c) ((cinfo[CHARMASK(c)]&_MG_D)!=0)
	+#define TOUPPER(c) ((c)-0x20)
	+#define TOLOWER(c) ((c)+0x20)
	+
	+/*
	+ * Generally useful thing for chars
	+ */
	+#define CCHR(x) ((x) ^ 0x40) /* CCHR('?') == DEL */
	+
	+#define K00 256
	+#define K01 257
	+#define K02 258
	+#define K03 259
	+#define K04 260
	+#define K05 261
	+#define K06 262
	+#define K07 263
	+#define K08 264
	+#define K09 265
	+#define K0A 266
	+#define K0B 267
	+#define K0C 268
	+#define K0D 269
	+#define K0E 270
	+#define K0F 271
	+#define K10 272
	+#define K11 273
	+#define K12 274
	+#define K13 275
	+#define K14 276
	+#define K15 277
	+#define K16 278
	+#define K17 279
	+#define K18 280
	+#define K19 281
	+#define K1A 282
	+#define K1B 283
	+#define K1C 284
	+#define K1D 285
	+#define K1E 286
	+#define K1F 287
	Index: contrib/mg/cinfo.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/cinfo.c
	@@ -0,0 +1,158 @@
	+/* $OpenBSD: cinfo.c,v 1.18 2015/03/19 21:22:15 bcallah Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * Character class tables.
	+ * Do it yourself character classification
	+ * macros, that understand the multinational character set,
	+ * and let me ask some questions the standard macros (in
	+ * ctype.h) don't let you ask.
	+ */
	+
	+#include <sys/queue.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <string.h>
	+
	+#include "def.h"
	+
	+/*
	+ * This table, indexed by a character drawn
	+ * from the 256 member character set, is used by my
	+ * own character type macros to answer questions about the
	+ * type of a character. It handles the full multinational
	+ * character set, and lets me ask some questions that the
	+ * standard "ctype" macros cannot ask.
	+ */
	+/*
	+ * Due to incompatible behaviour between "standard" emacs and
	+ * ctags word traversing, '_' character's value is changed on
	+ * the fly in ctags mode, hence non-const.
	+ */
	+char cinfo[256] = {
	+ _MG_C, _MG_C, _MG_C, _MG_C, /* 0x0X */
	+ _MG_C, _MG_C, _MG_C, _MG_C,
	+ _MG_C, _MG_C, _MG_C, _MG_C,
	+ _MG_C, _MG_C, _MG_C, _MG_C,
	+ _MG_C, _MG_C, _MG_C, _MG_C, /* 0x1X */
	+ _MG_C, _MG_C, _MG_C, _MG_C,
	+ _MG_C, _MG_C, _MG_C, _MG_C,
	+ _MG_C, _MG_C, _MG_C, _MG_C,
	+ 0, _MG_P, 0, 0, /* 0x2X */
	+ _MG_W, _MG_W, 0, _MG_W,
	+ 0, 0, 0, 0,
	+ 0, 0, _MG_P, 0,
	+ _MG_D \| _MG_W, _MG_D \| _MG_W, _MG_D \| _MG_W, _MG_D \| _MG_W, /* 0x3X */
	+ _MG_D \| _MG_W, _MG_D \| _MG_W, _MG_D \| _MG_W, _MG_D \| _MG_W,
	+ _MG_D \| _MG_W, _MG_D \| _MG_W, 0, 0,
	+ 0, 0, 0, _MG_P,
	+ 0, _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W, /* 0x4X */
	+ _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W,
	+ _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W,
	+ _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W,
	+ _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W, /* 0x5X */
	+ _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W,
	+ _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W, 0,
	+ 0, 0, 0, 0,
	+ 0, _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W, /* 0x6X */
	+ _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W,
	+ _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W,
	+ _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W,
	+ _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W, /* 0x7X */
	+ _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W,
	+ _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W, 0,
	+ 0, 0, 0, _MG_C,
	+ 0, 0, 0, 0, /* 0x8X */
	+ 0, 0, 0, 0,
	+ 0, 0, 0, 0,
	+ 0, 0, 0, 0,
	+ 0, 0, 0, 0, /* 0x9X */
	+ 0, 0, 0, 0,
	+ 0, 0, 0, 0,
	+ 0, 0, 0, 0,
	+ 0, 0, 0, 0, /* 0xAX */
	+ 0, 0, 0, 0,
	+ 0, 0, 0, 0,
	+ 0, 0, 0, 0,
	+ 0, 0, 0, 0, /* 0xBX */
	+ 0, 0, 0, 0,
	+ 0, 0, 0, 0,
	+ 0, 0, 0, 0,
	+ _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W, /* 0xCX */
	+ _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W,
	+ _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W,
	+ _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W,
	+ 0, _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W, /* 0xDX */
	+ _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W,
	+ _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W, _MG_U \| _MG_W,
	+ _MG_U \| _MG_W, _MG_U \| _MG_W, 0, _MG_W,
	+ _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W, /* 0xEX */
	+ _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W,
	+ _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W,
	+ _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W,
	+ 0, _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W, /* 0xFX */
	+ _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W,
	+ _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W, _MG_L \| _MG_W,
	+ _MG_L \| _MG_W, _MG_L \| _MG_W, 0, 0
	+};
	+
	+/*
	+ * Find the name of a keystroke. Needs to be changed to handle 8-bit printing
	+ * characters and function keys better. Returns a pointer to the terminating
	+ * '\0'. Returns NULL on failure.
	+ */
	+char *
	+getkeyname(char *cp, size_t len, int k)
	+{
	+ const char *np;
	+ size_t copied;
	+
	+ if (k < 0)
	+ k = CHARMASK(k); /* sign extended char */
	+ switch (k) {
	+ case CCHR('@'):
	+ np = "C-SPC";
	+ break;
	+ case CCHR('I'):
	+ np = "TAB";
	+ break;
	+ case CCHR('M'):
	+ np = "RET";
	+ break;
	+ case CCHR('['):
	+ np = "ESC";
	+ break;
	+ case ' ':
	+ np = "SPC";
	+ break; /* yuck again */
	+ case CCHR('?'):
	+ np = "DEL";
	+ break;
	+ default:
	+ if (k >= KFIRST && k <= KLAST &&
	+ (np = keystrings[k - KFIRST]) != NULL)
	+ break;
	+ if (k > CCHR('?')) {
	+ *cp++ = '0';
	+ *cp++ = ((k >> 6) & 7) + '0';
	+ *cp++ = ((k >> 3) & 7) + '0';
	+ *cp++ = (k & 7) + '0';
	+ *cp = '\0';
	+ return (cp);
	+ } else if (k < ' ') {
	+ *cp++ = 'C';
	+ *cp++ = '-';
	+ k = CCHR(k);
	+ if (ISUPPER(k))
	+ k = TOLOWER(k);
	+ }
	+ *cp++ = k;
	+ *cp = '\0';
	+ return (cp);
	+ }
	+ copied = strlcpy(cp, np, len);
	+ if (copied >= len)
	+ copied = len - 1;
	+ return (cp + copied);
	+}
	Index: contrib/mg/cmode.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/cmode.c
	@@ -0,0 +1,522 @@
	+/* $OpenBSD: cmode.c,v 1.17 2019/07/11 18:20:18 lum Exp $ */
	+/*
	+ * This file is in the public domain.
	+ *
	+ * Author: Kjell Wooding <kjell@openbsd.org>
	+ */
	+
	+/*
	+ * Implement an non-irritating KNF-compliant mode for editing
	+ * C code.
	+ */
	+
	+#include <sys/queue.h>
	+#include <ctype.h>
	+#include <signal.h>
	+#include <stdio.h>
	+
	+#include "def.h"
	+#include "funmap.h"
	+#include "kbd.h"
	+
	+/* Pull in from modes.c */
	+extern int changemode(int, int, char *);
	+
	+static int cc_strip_trailp = TRUE; /* Delete Trailing space? */
	+static int cc_basic_indent = 8; /* Basic Indent multiple */
	+static int cc_cont_indent = 4; /* Continued line indent */
	+static int cc_colon_indent = -8; /* Label / case indent */
	+
	+static int getmatch(int, int);
	+static int getindent(const struct line , int );
	+static int in_whitespace(struct line *, int);
	+static int findcolpos(const struct buffer , const struct line , int);
	+static struct line findnonblank(struct line );
	+static int isnonblank(const struct line *, int);
	+
	+void cmode_init(void);
	+int cc_comment(int, int);
	+
	+/* Keymaps */
	+
	+static PF cmode_brace[] = {
	+ cc_brace, /* } */
	+};
	+
	+static PF cmode_cCP[] = {
	+ compile, /* C-c P */
	+};
	+
	+
	+static PF cmode_cc[] = {
	+ NULL, /* ^C */
	+ rescan, /* ^D */
	+ rescan, /* ^E */
	+ rescan, /* ^F */
	+ rescan, /* ^G */
	+ rescan, /* ^H */
	+ cc_tab, /* ^I */
	+ rescan, /* ^J */
	+ rescan, /* ^K */
	+ rescan, /* ^L */
	+ cc_lfindent, /* ^M */
	+};
	+
	+static PF cmode_spec[] = {
	+ cc_char, /* : */
	+};
	+
	+static struct KEYMAPE (1) cmode_cmap = {
	+ 1,
	+ 1,
	+ rescan,
	+ {
	+ { 'P', 'P', cmode_cCP, NULL }
	+ }
	+};
	+
	+static struct KEYMAPE (3) cmodemap = {
	+ 3,
	+ 3,
	+ rescan,
	+ {
	+ { CCHR('C'), CCHR('M'), cmode_cc, (KEYMAP *) &cmode_cmap },
	+ { ':', ':', cmode_spec, NULL },
	+ { '}', '}', cmode_brace, NULL }
	+ }
	+};
	+
	+/* Funtion, Mode hooks */
	+
	+void
	+cmode_init(void)
	+{
	+ funmap_add(cmode, "c-mode", 0);
	+ funmap_add(cc_char, "c-handle-special-char", 0);
	+ funmap_add(cc_brace, "c-handle-special-brace", 0);
	+ funmap_add(cc_tab, "c-tab-or-indent", 0);
	+ funmap_add(cc_indent, "c-indent", 0);
	+ funmap_add(cc_lfindent, "c-indent-and-newline", 0);
	+ maps_add((KEYMAP *)&cmodemap, "c");
	+}
	+
	+/*
	+ * Enable/toggle c-mode
	+ */
	+int
	+cmode(int f, int n)
	+{
	+ return(changemode(f, n, "c"));
	+}
	+
	+/*
	+ * Handle special C character - selfinsert then indent.
	+ */
	+int
	+cc_char(int f, int n)
	+{
	+ if (n < 0)
	+ return (FALSE);
	+ if (selfinsert(FFRAND, n) == FALSE)
	+ return (FALSE);
	+ return (cc_indent(FFRAND, n));
	+}
	+
	+/*
	+ * Handle special C character - selfinsert then indent.
	+ */
	+int
	+cc_brace(int f, int n)
	+{
	+ if (n < 0)
	+ return (FALSE);
	+ if (showmatch(FFRAND, 1) == FALSE)
	+ return (FALSE);
	+ return (cc_indent(FFRAND, n));
	+}
	+
	+
	+/*
	+ * If we are in the whitespace at the beginning of the line,
	+ * simply act as a regular tab. If we are not, indent
	+ * current line according to whitespace rules.
	+ */
	+int
	+cc_tab(int f, int n)
	+{
	+ int inwhitep = FALSE; /* In leading whitespace? */
	+
	+ inwhitep = in_whitespace(curwp->w_dotp, llength(curwp->w_dotp));
	+
	+ /* If empty line, or in whitespace */
	+ if (llength(curwp->w_dotp) == 0 \|\| inwhitep)
	+ return (selfinsert(f, n));
	+
	+ return (cc_indent(FFRAND, 1));
	+}
	+
	+/*
	+ * Attempt to indent current line according to KNF rules.
	+ */
	+int
	+cc_indent(int f, int n)
	+{
	+ int pi, mi; /* Previous indents (mi is ignored) */
	+ int ci; /* current indent */
	+ struct line *lp;
	+ int ret;
	+
	+ if (n < 0)
	+ return (FALSE);
	+
	+ undo_boundary_enable(FFRAND, 0);
	+ if (cc_strip_trailp)
	+ deltrailwhite(FFRAND, 1);
	+
	+ /*
	+ * Search backwards for a non-blank, non-preprocessor,
	+ * non-comment line
	+ */
	+
	+ lp = findnonblank(curwp->w_dotp);
	+
	+ pi = getindent(lp, &mi);
	+
	+ /* Strip leading space on current line */
	+ delleadwhite(FFRAND, 1);
	+ /* current indent is computed only to current position */
	+ (void)getindent(curwp->w_dotp, &ci);
	+
	+ if (pi + ci < 0)
	+ ret = indent(FFOTHARG, 0);
	+ else
	+ ret = indent(FFOTHARG, pi + ci);
	+
	+ undo_boundary_enable(FFRAND, 1);
	+
	+ return (ret);
	+}
	+
	+/*
	+ * Indent-and-newline (technically, newline then indent)
	+ */
	+int
	+cc_lfindent(int f, int n)
	+{
	+ if (n < 0)
	+ return (FALSE);
	+ if (enewline(FFRAND, 1) == FALSE)
	+ return (FALSE);
	+ return (cc_indent(FFRAND, n));
	+}
	+
	+/*
	+ * Get the level of indention after line lp is processed
	+ * Note getindent has two returns:
	+ * curi = value if indenting current line.
	+ * return value = value affecting subsequent lines.
	+ */
	+static int
	+getindent(const struct line lp, int curi)
	+{
	+ int lo, co; /* leading space, current offset*/
	+ int nicol = 0; /* position count */
	+ int c = '\0'; /* current char */
	+ int newind = 0; /* new index value */
	+ int stringp = FALSE; /* in string? */
	+ int escp = FALSE; /* Escape char? */
	+ int lastc = '\0'; /* Last matched string delimeter */
	+ int nparen = 0; /* paren count */
	+ int obrace = 0; /* open brace count */
	+ int cbrace = 0; /* close brace count */
	+ int firstnwsp = FALSE; /* First nonspace encountered? */
	+ int colonp = FALSE; /* Did we see a colon? */
	+ int questionp = FALSE; /* Did we see a question mark? */
	+ int slashp = FALSE; /* Slash? */
	+ int astp = FALSE; /* Asterisk? */
	+ int cpos = -1; /* comment position */
	+ int cppp = FALSE; /* Preprocessor command? */
	+
	+ *curi = 0;
	+
	+ /* Compute leading space */
	+ for (lo = 0; lo < llength(lp); lo++) {
	+ if (!isspace(c = lgetc(lp, lo)))
	+ break;
	+ if (c == '\t'
	+#ifdef NOTAB
	+ && !(curbp->b_flag & BFNOTAB)
	+#endif /* NOTAB */
	+ ) {
	+ nicol \|= 0x07;
	+ }
	+ nicol++;
	+ }
	+
	+ /* If last line was blank, choose 0 */
	+ if (lo == llength(lp))
	+ nicol = 0;
	+
	+ newind = 0;
	+ /* Compute modifiers */
	+ for (co = lo; co < llength(lp); co++) {
	+ c = lgetc(lp, co);
	+ /* We have a non-whitespace char */
	+ if (!firstnwsp && !isspace(c)) {
	+ if (c == '#')
	+ cppp = TRUE;
	+ firstnwsp = TRUE;
	+ }
	+ if (c == '\\')
	+ escp = !escp;
	+ else if (stringp) {
	+ if (!escp && (c == '"' \|\| c == '\'')) {
	+ /* unescaped string char */
	+ if (getmatch(c, lastc))
	+ stringp = FALSE;
	+ }
	+ } else if (c == '"' \|\| c == '\'') {
	+ stringp = TRUE;
	+ lastc = c;
	+ } else if (c == '(') {
	+ nparen++;
	+ } else if (c == ')') {
	+ nparen--;
	+ } else if (c == '{') {
	+ obrace++;
	+ firstnwsp = FALSE;
	+ } else if (c == '}') {
	+ cbrace++;
	+ } else if (c == '?') {
	+ questionp = TRUE;
	+ } else if (c == ':') {
	+ /* ignore (foo ? bar : baz) construct */
	+ if (!questionp)
	+ colonp = TRUE;
	+ } else if (c == '/') {
	+ /* first nonwhitespace? -> indent */
	+ if (firstnwsp) {
	+ /* If previous char asterisk -> close */
	+ if (astp)
	+ cpos = -1;
	+ else
	+ slashp = TRUE;
	+ }
	+ } else if (c == '*') {
	+ /* If previous char slash -> open */
	+ if (slashp)
	+ cpos = co;
	+ else
	+ astp = TRUE;
	+ } else if (firstnwsp) {
	+ firstnwsp = FALSE;
	+ }
	+
	+ /* Reset matches that apply to next character only */
	+ if (c != '\\')
	+ escp = FALSE;
	+ if (c != '*')
	+ astp = FALSE;
	+ if (c != '/')
	+ slashp = FALSE;
	+ }
	+ /*
	+ * If not terminated with a semicolon, and brace or paren open.
	+ * we continue
	+ */
	+ if (colonp) {
	+ *curi += cc_colon_indent;
	+ newind -= cc_colon_indent;
	+ }
	+
	+ curi -= (cbrace) cc_basic_indent;
	+ newind += obrace * cc_basic_indent;
	+
	+ if (nparen < 0)
	+ newind -= cc_cont_indent;
	+ else if (nparen > 0)
	+ newind += cc_cont_indent;
	+
	+ *curi += nicol;
	+
	+ /* Ignore preprocessor. Otherwise, add current column */
	+ if (cppp) {
	+ newind = nicol;
	+ *curi = 0;
	+ } else {
	+ newind += nicol;
	+ }
	+
	+ if (cpos != -1)
	+ newind = findcolpos(curbp, lp, cpos);
	+
	+ return (newind);
	+}
	+
	+/*
	+ * Given a delimeter and its purported mate, tell us if they
	+ * match.
	+ */
	+static int
	+getmatch(int c, int mc)
	+{
	+ int match = FALSE;
	+
	+ switch (c) {
	+ case '"':
	+ match = (mc == '"');
	+ break;
	+ case '\'':
	+ match = (mc == '\'');
	+ break;
	+ case '(':
	+ match = (mc == ')');
	+ break;
	+ case '[':
	+ match = (mc == ']');
	+ break;
	+ case '{':
	+ match = (mc == '}');
	+ break;
	+ }
	+
	+ return (match);
	+}
	+
	+static int
	+in_whitespace(struct line *lp, int len)
	+{
	+ int lo;
	+ int inwhitep = FALSE;
	+
	+ for (lo = 0; lo < len; lo++) {
	+ if (!isspace(lgetc(lp, lo)))
	+ break;
	+ if (lo == len - 1)
	+ inwhitep = TRUE;
	+ }
	+
	+ return (inwhitep);
	+}
	+
	+
	+/* convert a line/offset pair to a column position (for indenting) */
	+static int
	+findcolpos(const struct buffer bp, const struct line lp, int lo)
	+{
	+ int col, i, c;
	+ char tmp[5];
	+
	+ /* determine column */
	+ col = 0;
	+
	+ for (i = 0; i < lo; ++i) {
	+ c = lgetc(lp, i);
	+ if (c == '\t'
	+#ifdef NOTAB
	+ && !(bp->b_flag & BFNOTAB)
	+#endif /* NOTAB */
	+ ) {
	+ col \|= 0x07;
	+ col++;
	+ } else if (ISCTRL(c) != FALSE)
	+ col += 2;
	+ else if (isprint(c)) {
	+ col++;
	+ } else {
	+ col += snprintf(tmp, sizeof(tmp), "\\%o", c);
	+ }
	+
	+ }
	+ return (col);
	+}
	+
	+/*
	+ * Find a non-blank line, searching backwards from the supplied line pointer.
	+ * For C, nonblank is non-preprocessor, non C++, and accounts
	+ * for complete C-style comments.
	+ */
	+static struct line *
	+findnonblank(struct line *lp)
	+{
	+ int lo;
	+ int nonblankp = FALSE;
	+ int commentp = FALSE;
	+ int slashp;
	+ int astp;
	+ int c;
	+
	+ while (lback(lp) != curbp->b_headp && (commentp \|\| !nonblankp)) {
	+ lp = lback(lp);
	+ slashp = FALSE;
	+ astp = FALSE;
	+
	+ /* Potential nonblank? */
	+ nonblankp = isnonblank(lp, llength(lp));
	+
	+ /*
	+ * Search from end, removing complete C-style
	+ * comments. If one is found, ignore it and
	+ * test for nonblankness from where it starts.
	+ */
	+ for (lo = llength(lp) - 1; lo >= 0; lo--) {
	+ if (!isspace(c = lgetc(lp, lo))) {
	+ if (commentp) { /* find comment "open" */
	+ if (c == '*')
	+ astp = TRUE;
	+ else if (astp && c == '/') {
	+ commentp = FALSE;
	+ /* whitespace to here? */
	+ nonblankp = isnonblank(lp, lo);
	+ }
	+ } else { /* find comment "close" */
	+ if (c == '/')
	+ slashp = TRUE;
	+ else if (slashp && c == '*')
	+ /* found a comment */
	+ commentp = TRUE;
	+ }
	+ }
	+ }
	+ }
	+
	+ /* Rewound to start of file? */
	+ if (lback(lp) == curbp->b_headp && !nonblankp)
	+ return (curbp->b_headp);
	+
	+ return (lp);
	+}
	+
	+/*
	+ * Given a line, scan forward to 'omax' and determine if we
	+ * are all C whitespace.
	+ * Note that preprocessor directives and C++-style comments
	+ * count as whitespace. C-style comments do not, and must
	+ * be handled elsewhere.
	+ */
	+static int
	+isnonblank(const struct line *lp, int omax)
	+{
	+ int nonblankp = FALSE; /* Return value */
	+ int slashp = FALSE; /* Encountered slash */
	+ int lo; /* Loop index */
	+ int c; /* char being read */
	+
	+ /* Scan from front for preprocessor, C++ comments */
	+ for (lo = 0; lo < omax; lo++) {
	+ if (!isspace(c = lgetc(lp, lo))) {
	+ /* Possible nonblank line */
	+ nonblankp = TRUE;
	+ /* skip // and # starts */
	+ if (c == '#' \|\| (slashp && c == '/')) {
	+ nonblankp = FALSE;
	+ break;
	+ } else if (!slashp && c == '/') {
	+ slashp = TRUE;
	+ continue;
	+ }
	+ }
	+ slashp = FALSE;
	+ }
	+ return (nonblankp);
	+}
	Index: contrib/mg/common.h
	===================================================================
	--- /dev/null
	+++ contrib/mg/common.h
	@@ -0,0 +1,35 @@
	+/*
	+ * Support for non-OpenBSD systems.
	+ */
	+
	+/* From OpenBSD sys/stat.h; glibc io/sys/stat.h agrees */
	+#ifndef DEFFILEMODE
	+#define DEFFILEMODE 0000666
	+#endif
	+
	+/* From OpenBSD regex.h */
	+#ifndef REG_STARTEND
	+#define REG_STARTEND 00004
	+#endif
	+
	+/* From OpenBSD sys/queue.h */
	+#ifndef SLIST_FOREACH_SAFE
	+#define SLIST_FOREACH_SAFE(var, head, field, tvar) \
	+ for ((var) = SLIST_FIRST(head); \
	+ (var) && ((tvar) = SLIST_NEXT(var, field), 1); \
	+ (var) = (tvar))
	+#endif
	+
	+/* From OpenBSD sys/queue.h */
	+#ifndef TAILQ_END
	+#define TAILQ_END(head) NULL
	+#endif
	+
	+/* From OpenBSD sys/queue.h */
	+#ifndef TAILQ_FOREACH_SAFE
	+#define TAILQ_FOREACH_SAFE(var, head, field, tvar) \
	+ for ((var) = TAILQ_FIRST(head); \
	+ (var) != TAILQ_END(head) && \
	+ ((tvar) = TAILQ_NEXT(var, field), 1); \
	+ (var) = (tvar))
	+#endif
	Index: contrib/mg/compile.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/compile.c
	@@ -0,0 +1,670 @@
	+/* $NetBSD: compile.c,v 1.12 2017/05/04 09:46:30 roy Exp $ */
	+
	+/*
	+ * Copyright (c) 2009, 2010, 2011 The NetBSD Foundation, Inc.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Roy Marples.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ */
	+
	+#include <sys/cdefs.h>
	+
	+#include <ctype.h>
	+#include <err.h>
	+#include <errno.h>
	+#include <limits.h>
	+#include <stdarg.h>
	+#include <stdlib.h>
	+#include <stdint.h>
	+#include <stdio.h>
	+#include <string.h>
	+
	+#include "term_private.h"
	+#include "terminfo_term.h"
	+
	+/* From NetBSD sys/arch/hpc/stand/include/machine/endian.h */
	+static uint16_t
	+le16dec(const void *buf)
	+{
	+ const uint8_t p = (const uint8_t )buf;
	+
	+ return ((p[1] << 8) \| p[0]);
	+}
	+
	+static void
	+le16enc(void *buf, uint32_t u)
	+{
	+ uint8_t p = (uint8_t ) buf;
	+
	+ p[0] = u & 0xff;
	+ p[1] = ((unsigned)u >> 8) & 0xff;
	+}
	+
	+static void
	+dowarn(int flags, const char *fmt, ...)
	+{
	+ va_list va;
	+
	+ errno = EINVAL;
	+ if (flags & TIC_WARNING) {
	+ va_start(va, fmt);
	+ vwarnx(fmt, va);
	+ va_end(va);
	+ }
	+}
	+
	+char *
	+_ti_grow_tbuf(TBUF *tbuf, size_t len)
	+{
	+ char *buf;
	+ size_t l;
	+
	+ l = tbuf->bufpos + len;
	+ if (l > tbuf->buflen) {
	+ if (tbuf->buflen == 0)
	+ buf = malloc(l);
	+ else
	+ buf = realloc(tbuf->buf, l);
	+ if (buf == NULL)
	+ return NULL;
	+ tbuf->buf = buf;
	+ tbuf->buflen = l;
	+ }
	+ return tbuf->buf;
	+}
	+
	+char *
	+_ti_find_cap(TBUF *tbuf, char type, short ind)
	+{
	+ size_t n;
	+ uint16_t num;
	+ char *cap;
	+
	+ cap = tbuf->buf;
	+ for (n = tbuf->entries; n > 0; n--) {
	+ num = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ if ((short)num == ind)
	+ return cap;
	+ switch (type) {
	+ case 'f':
	+ cap++;
	+ break;
	+ case 'n':
	+ cap += sizeof(uint16_t);
	+ break;
	+ case 's':
	+ num = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ cap += num;
	+ break;
	+ }
	+ }
	+
	+ errno = ESRCH;
	+ return NULL;
	+}
	+
	+char *
	+_ti_find_extra(TBUF tbuf, const char code)
	+{
	+ size_t n;
	+ uint16_t num;
	+ char *cap;
	+
	+ cap = tbuf->buf;
	+ for (n = tbuf->entries; n > 0; n--) {
	+ num = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ if (strcmp(cap, code) == 0)
	+ return cap + num;
	+ cap += num;
	+ switch (*cap++) {
	+ case 'f':
	+ cap++;
	+ break;
	+ case 'n':
	+ cap += sizeof(uint16_t);
	+ break;
	+ case 's':
	+ num = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ cap += num;
	+ break;
	+ }
	+ }
	+
	+ errno = ESRCH;
	+ return NULL;
	+}
	+
	+size_t
	+_ti_store_extra(TIC tic, int wrn, char id, char type, char flag, short num,
	+ char *str, size_t strl, int flags)
	+{
	+ size_t l;
	+
	+ if (strcmp(id, "use") != 0) {
	+ if (_ti_find_extra(&tic->extras, id) != NULL)
	+ return 0;
	+ if (!(flags & TIC_EXTRA)) {
	+ if (wrn != 0)
	+ dowarn(flags, "%s: %s: unknown capability",
	+ tic->name, id);
	+ return 0;
	+ }
	+ }
	+
	+ l = strlen(id) + 1;
	+ if (l > UINT16_T_MAX) {
	+ dowarn(flags, "%s: %s: cap name is too long", tic->name, id);
	+ return 0;
	+ }
	+
	+ if (!_ti_grow_tbuf(&tic->extras,
	+ l + strl + (sizeof(uint16_t) * 2) + 1))
	+ return 0;
	+ le16enc(tic->extras.buf + tic->extras.bufpos, (uint16_t)l);
	+ tic->extras.bufpos += sizeof(uint16_t);
	+ memcpy(tic->extras.buf + tic->extras.bufpos, id, l);
	+ tic->extras.bufpos += l;
	+ tic->extras.buf[tic->extras.bufpos++] = type;
	+ switch (type) {
	+ case 'f':
	+ tic->extras.buf[tic->extras.bufpos++] = flag;
	+ break;
	+ case 'n':
	+ le16enc(tic->extras.buf + tic->extras.bufpos, (uint16_t)num);
	+ tic->extras.bufpos += sizeof(uint16_t);
	+ break;
	+ case 's':
	+ le16enc(tic->extras.buf + tic->extras.bufpos, (uint16_t)strl);
	+ tic->extras.bufpos += sizeof(uint16_t);
	+ memcpy(tic->extras.buf + tic->extras.bufpos, str, strl);
	+ tic->extras.bufpos += strl;
	+ break;
	+ }
	+ tic->extras.entries++;
	+ return 1;
	+}
	+
	+ssize_t
	+_ti_flatten(uint8_t *buf, const TIC tic)
	+{
	+ size_t buflen, len, alen, dlen;
	+ uint8_t *cap;
	+
	+ len = strlen(tic->name) + 1;
	+ if (tic->alias == NULL)
	+ alen = 0;
	+ else
	+ alen = strlen(tic->alias) + 1;
	+ if (tic->desc == NULL)
	+ dlen = 0;
	+ else
	+ dlen = strlen(tic->desc) + 1;
	+ buflen = sizeof(char) +
	+ sizeof(uint16_t) + len +
	+ sizeof(uint16_t) + alen +
	+ sizeof(uint16_t) + dlen +
	+ (sizeof(uint16_t) * 2) + tic->flags.bufpos +
	+ (sizeof(uint16_t) * 2) + tic->nums.bufpos +
	+ (sizeof(uint16_t) * 2) + tic->strs.bufpos +
	+ (sizeof(uint16_t) * 2) + tic->extras.bufpos;
	+ *buf = malloc(buflen);
	+ if (*buf == NULL)
	+ return -1;
	+
	+ cap = *buf;
	+ *cap++ = 1;
	+ le16enc(cap, (uint16_t)len);
	+ cap += sizeof(uint16_t);
	+ memcpy(cap, tic->name, len);
	+ cap += len;
	+
	+ le16enc(cap, (uint16_t)alen);
	+ cap += sizeof(uint16_t);
	+ if (tic->alias != NULL) {
	+ memcpy(cap, tic->alias, alen);
	+ cap += alen;
	+ }
	+ le16enc(cap, (uint16_t)dlen);
	+ cap += sizeof(uint16_t);
	+ if (tic->desc != NULL) {
	+ memcpy(cap, tic->desc, dlen);
	+ cap += dlen;
	+ }
	+
	+ if (tic->flags.entries == 0) {
	+ le16enc(cap, 0);
	+ cap += sizeof(uint16_t);
	+ } else {
	+ le16enc(cap, (uint16_t)(tic->flags.bufpos + sizeof(uint16_t)));
	+ cap += sizeof(uint16_t);
	+ le16enc(cap, (uint16_t)tic->flags.entries);
	+ cap += sizeof(uint16_t);
	+ memcpy(cap, tic->flags.buf, tic->flags.bufpos);
	+ cap += tic->flags.bufpos;
	+ }
	+
	+ if (tic->nums.entries == 0) {
	+ le16enc(cap, 0);
	+ cap += sizeof(uint16_t);
	+ } else {
	+ le16enc(cap, (uint16_t)(tic->nums.bufpos + sizeof(uint16_t)));
	+ cap += sizeof(uint16_t);
	+ le16enc(cap, (uint16_t)tic->nums.entries);
	+ cap += sizeof(uint16_t);
	+ memcpy(cap, tic->nums.buf, tic->nums.bufpos);
	+ cap += tic->nums.bufpos;
	+ }
	+
	+ if (tic->strs.entries == 0) {
	+ le16enc(cap, 0);
	+ cap += sizeof(uint16_t);
	+ } else {
	+ le16enc(cap, (uint16_t)(tic->strs.bufpos + sizeof(uint16_t)));
	+ cap += sizeof(uint16_t);
	+ le16enc(cap, (uint16_t)tic->strs.entries);
	+ cap += sizeof(uint16_t);
	+ memcpy(cap, tic->strs.buf, tic->strs.bufpos);
	+ cap += tic->strs.bufpos;
	+ }
	+
	+ if (tic->extras.entries == 0) {
	+ le16enc(cap, 0);
	+ cap += sizeof(uint16_t);
	+ } else {
	+ le16enc(cap, (uint16_t)(tic->extras.bufpos + sizeof(uint16_t)));
	+ cap += sizeof(uint16_t);
	+ le16enc(cap, (uint16_t)tic->extras.entries);
	+ cap += sizeof(uint16_t);
	+ memcpy(cap, tic->extras.buf, tic->extras.bufpos);
	+ cap += tic->extras.bufpos;
	+ }
	+
	+ return cap - *buf;
	+}
	+
	+static int
	+encode_string(const char term, const char cap, TBUF tbuf, const char str,
	+ int flags)
	+{
	+ int slash, i, num;
	+ char ch, p, s, last;
	+
	+ if (_ti_grow_tbuf(tbuf, strlen(str) + 1) == NULL)
	+ return -1;
	+ p = s = tbuf->buf + tbuf->bufpos;
	+ slash = 0;
	+ last = '\0';
	+ /* Convert escape codes */
	+ while ((ch = *str++) != '\0') {
	+ if (ch == '\n') {
	+ /* Following a newline, strip leading whitespace from
	+ * capability strings. */
	+ while (isspace((unsigned char)*str))
	+ str++;
	+ continue;
	+ }
	+ if (slash == 0 && ch == '\\') {
	+ slash = 1;
	+ continue;
	+ }
	+ if (slash == 0) {
	+ if (last != '%' && ch == '^') {
	+ ch = *str++;
	+ if (((unsigned char)ch) >= 128)
	+ dowarn(flags,
	+ "%s: %s: illegal ^ character",
	+ term, cap);
	+ if (ch == '\0')
	+ break;
	+ if (ch == '?')
	+ ch = '\177';
	+ else if ((ch &= 037) == 0)
	+ ch = (char)128;
	+ } else if (!isprint((unsigned char)ch))
	+ dowarn(flags,
	+ "%s: %s: unprintable character",
	+ term, cap);
	+ *p++ = ch;
	+ last = ch;
	+ continue;
	+ }
	+ slash = 0;
	+ if (ch >= '0' && ch <= '7') {
	+ num = ch - '0';
	+ for (i = 0; i < 2; i++) {
	+ if (str < '0' \|\| str > '7') {
	+ if (isdigit((unsigned char)*str))
	+ dowarn(flags,
	+ "%s: %s: non octal"
	+ " digit", term, cap);
	+ else
	+ break;
	+ }
	+ num = num * 8 + *str++ - '0';
	+ }
	+ if (num == 0)
	+ num = 0200;
	+ *p++ = (char)num;
	+ continue;
	+ }
	+ switch (ch) {
	+ case 'a':
	+ *p++ = '\a';
	+ break;
	+ case 'b':
	+ *p++ = '\b';
	+ break;
	+ case 'e': /* FALLTHROUGH */
	+ case 'E':
	+ *p++ = '\033';
	+ break;
	+ case 'f':
	+ *p++ = '\014';
	+ break;
	+ case 'l': /* FALLTHROUGH */
	+ case 'n':
	+ *p++ = '\n';
	+ break;
	+ case 'r':
	+ *p++ = '\r';
	+ break;
	+ case 's':
	+ *p++ = ' ';
	+ break;
	+ case 't':
	+ *p++ = '\t';
	+ break;
	+ default:
	+ /* We should warn here */
	+ case '^':
	+ case ',':
	+ case ':':
	+ case '\|':
	+ *p++ = ch;
	+ break;
	+ }
	+ last = ch;
	+ }
	+ *p++ = '\0';
	+ tbuf->bufpos += (size_t)(p - s);
	+ return 0;
	+}
	+
	+char *
	+_ti_get_token(char **cap, char sep)
	+{
	+ char esc, *token;
	+
	+ while (isspace((unsigned char)**cap))
	+ (*cap)++;
	+ if (**cap == '\0')
	+ return NULL;
	+
	+ /* We can't use stresep(3) as ^ we need two escape chars */
	+ esc = '\0';
	+ for (token = *cap;
	+ cap != '\0' && (esc != '\0' \|\| cap != sep);
	+ (*cap)++)
	+ {
	+ if (esc == '\0') {
	+ if (cap == '\\' \|\| cap == '^')
	+ esc = **cap;
	+ } else {
	+ /* termcap /E/ is valid */
	+ if (sep == ':' && esc == '\\' && **cap == 'E')
	+ esc = 'x';
	+ else
	+ esc = '\0';
	+ }
	+ }
	+
	+ if (**cap != '\0')
	+ (cap)++ = '\0';
	+
	+ return token;
	+}
	+
	+TIC *
	+_ti_compile(char *cap, int flags)
	+{
	+ char token, p, e, name, desc, alias;
	+ signed char flag;
	+ long cnum;
	+ short ind, num;
	+ size_t len;
	+ TBUF buf;
	+ TIC *tic;
	+
	+ name = _ti_get_token(&cap, ',');
	+ if (name == NULL) {
	+ dowarn(flags, "no seperator found: %s", cap);
	+ return NULL;
	+ }
	+ desc = strrchr(name, '\|');
	+ if (desc != NULL)
	+ *desc++ = '\0';
	+ alias = strchr(name, '\|');
	+ if (alias != NULL)
	+ *alias++ = '\0';
	+
	+ tic = calloc(sizeof(*tic), 1);
	+ if (tic == NULL)
	+ return NULL;
	+
	+ buf.buf = NULL;
	+ buf.buflen = 0;
	+
	+ tic->name = strdup(name);
	+ if (tic->name == NULL)
	+ goto error;
	+ if (alias != NULL && flags & TIC_ALIAS) {
	+ tic->alias = strdup(alias);
	+ if (tic->alias == NULL)
	+ goto error;
	+ }
	+ if (desc != NULL && flags & TIC_DESCRIPTION) {
	+ tic->desc = strdup(desc);
	+ if (tic->desc == NULL)
	+ goto error;
	+ }
	+
	+ for (token = _ti_get_token(&cap, ',');
	+ token != NULL && *token != '\0';
	+ token = _ti_get_token(&cap, ','))
	+ {
	+ /* Skip commented caps */
	+ if (!(flags & TIC_COMMENT) && token[0] == '.')
	+ continue;
	+
	+ /* Obsolete entries */
	+ if (token[0] == 'O' && token[1] == 'T') {
	+ if (!(flags & TIC_EXTRA))
	+ continue;
	+ token += 2;
	+ }
	+
	+ /* str cap */
	+ p = strchr(token, '=');
	+ if (p != NULL) {
	+ *p++ = '\0';
	+ /* Don't use the string if we already have it */
	+ ind = (short)_ti_strindex(token);
	+ if (ind != -1 &&
	+ _ti_find_cap(&tic->strs, 's', ind) != NULL)
	+ continue;
	+
	+ /* Encode the string to our scratch buffer */
	+ buf.bufpos = 0;
	+ if (encode_string(tic->name, token,
	+ &buf, p, flags) == -1)
	+ goto error;
	+ if (buf.bufpos > UINT16_T_MAX) {
	+ dowarn(flags, "%s: %s: string is too long",
	+ tic->name, token);
	+ continue;
	+ }
	+ if (!VALID_STRING(buf.buf)) {
	+ dowarn(flags, "%s: %s: invalid string",
	+ tic->name, token);
	+ continue;
	+ }
	+
	+ if (ind == -1)
	+ _ti_store_extra(tic, 1, token, 's', -1, -2,
	+ buf.buf, buf.bufpos, flags);
	+ else {
	+ if (!_ti_grow_tbuf(&tic->strs,
	+ (sizeof(uint16_t) * 2) + buf.bufpos))
	+ goto error;
	+ le16enc(tic->strs.buf + tic->strs.bufpos, (uint16_t)ind);
	+ tic->strs.bufpos += sizeof(uint16_t);
	+ le16enc(tic->strs.buf + tic->strs.bufpos,
	+ (uint16_t)buf.bufpos);
	+ tic->strs.bufpos += sizeof(uint16_t);
	+ memcpy(tic->strs.buf + tic->strs.bufpos,
	+ buf.buf, buf.bufpos);
	+ tic->strs.bufpos += buf.bufpos;
	+ tic->strs.entries++;
	+ }
	+ continue;
	+ }
	+
	+ /* num cap */
	+ p = strchr(token, '#');
	+ if (p != NULL) {
	+ *p++ = '\0';
	+ /* Don't use the number if we already have it */
	+ ind = (short)_ti_numindex(token);
	+ if (ind != -1 &&
	+ _ti_find_cap(&tic->nums, 'n', ind) != NULL)
	+ continue;
	+
	+ cnum = strtol(p, &e, 0);
	+ if (*e != '\0') {
	+ dowarn(flags, "%s: %s: not a number",
	+ tic->name, token);
	+ continue;
	+ }
	+ if (!VALID_NUMERIC(cnum)) {
	+ dowarn(flags, "%s: %s: number out of range",
	+ tic->name, token);
	+ continue;
	+ }
	+ num = (short)cnum;
	+ if (ind == -1)
	+ _ti_store_extra(tic, 1, token, 'n', -1,
	+ num, NULL, 0, flags);
	+ else {
	+ if (_ti_grow_tbuf(&tic->nums,
	+ sizeof(uint16_t) * 2) == NULL)
	+ goto error;
	+ le16enc(tic->nums.buf + tic->nums.bufpos,
	+ (uint16_t)ind);
	+ tic->nums.bufpos += sizeof(uint16_t);
	+ le16enc(tic->nums.buf + tic->nums.bufpos,
	+ (uint16_t)num);
	+ tic->nums.bufpos += sizeof(uint16_t);
	+ tic->nums.entries++;
	+ }
	+ continue;
	+ }
	+
	+ flag = 1;
	+ len = strlen(token) - 1;
	+ if (token[len] == '@') {
	+ flag = CANCELLED_BOOLEAN;
	+ token[len] = '\0';
	+ }
	+ ind = (short)_ti_flagindex(token);
	+ if (ind == -1 && flag == CANCELLED_BOOLEAN) {
	+ if ((ind = (short)_ti_numindex(token)) != -1) {
	+ if (_ti_find_cap(&tic->nums, 'n', ind) != NULL)
	+ continue;
	+ if (_ti_grow_tbuf(&tic->nums,
	+ sizeof(uint16_t) * 2) == NULL)
	+ goto error;
	+ le16enc(tic->nums.buf + tic->nums.bufpos,
	+ (uint16_t)ind);
	+ tic->nums.bufpos += sizeof(uint16_t);
	+ le16enc(tic->nums.buf + tic->nums.bufpos,
	+ (uint16_t)CANCELLED_NUMERIC);
	+ tic->nums.bufpos += sizeof(uint16_t);
	+ tic->nums.entries++;
	+ continue;
	+ } else if ((ind = (short)_ti_strindex(token)) != -1) {
	+ if (_ti_find_cap(&tic->strs, 's', ind) != NULL)
	+ continue;
	+ if (_ti_grow_tbuf(&tic->strs,
	+ (sizeof(uint16_t) * 2) + 1) == NULL)
	+ goto error;
	+ le16enc(tic->strs.buf + tic->strs.bufpos, (uint16_t)ind);
	+ tic->strs.bufpos += sizeof(uint16_t);
	+ le16enc(tic->strs.buf + tic->strs.bufpos, 0);
	+ tic->strs.bufpos += sizeof(uint16_t);
	+ tic->strs.entries++;
	+ continue;
	+ }
	+ }
	+ if (ind == -1)
	+ _ti_store_extra(tic, 1, token, 'f', flag, 0, NULL, 0,
	+ flags);
	+ else if (_ti_find_cap(&tic->flags, 'f', ind) == NULL) {
	+ if (_ti_grow_tbuf(&tic->flags, sizeof(uint16_t) + 1)
	+ == NULL)
	+ goto error;
	+ le16enc(tic->flags.buf + tic->flags.bufpos,
	+ (uint16_t)ind);
	+ tic->flags.bufpos += sizeof(uint16_t);
	+ tic->flags.buf[tic->flags.bufpos++] = flag;
	+ tic->flags.entries++;
	+ }
	+ }
	+
	+ free(buf.buf);
	+ return tic;
	+
	+error:
	+ free(buf.buf);
	+ _ti_freetic(tic);
	+ return NULL;
	+}
	+
	+void
	+_ti_freetic(TIC *tic)
	+{
	+
	+ if (tic != NULL) {
	+ free(tic->name);
	+ free(tic->alias);
	+ free(tic->desc);
	+ free(tic->extras.buf);
	+ free(tic->flags.buf);
	+ free(tic->nums.buf);
	+ free(tic->strs.buf);
	+ free(tic);
	+ }
	+}
	Index: contrib/mg/compiled_terms.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/compiled_terms.c
	@@ -0,0 +1,1650 @@
	+/* DO NOT EDIT
	+ * Automatically generated from terminfo */
	+
	+struct compiled_term {
	+ const char *name;
	+ const char *cap;
	+ size_t caplen;
	+};
	+
	+const struct compiled_term compiled_terms[] = {
	+ {
	+ "ansi",
	+ "\001\005\000\141\156\163\151\000\000\000\000\000\016\000\004"
	+ "\000\036\000\001\001\000\001\026\000\001\027\000\001\032\000"
	+ "\006\000\016\000\010\000\025\000\003\000\021\000\100\000\004"
	+ "\000\120\000\007\000\010\000\012\000\030\000\142\003\107\000"
	+ "\200\001\013\000\033\133\045\151\045\144\073\045\144\122\000"
	+ "\201\001\005\000\033\133\066\156\000\202\001\023\000\033\133"
	+ "\077\045\133\073\060\061\062\063\064\065\066\067\070\071\135"
	+ "\143\000\203\001\004\000\033\133\143\000\052\001\011\000\033"
	+ "\133\063\071\073\064\071\155\000\132\001\012\000\033\133\064"
	+ "\045\160\061\045\144\155\000\133\001\012\000\033\133\063\045"
	+ "\160\061\045\144\155\000\110\000\005\000\033\133\070\155\000"
	+ "\134\001\126\000\033\133\060\073\061\060\045\077\045\160\061"
	+ "\045\164\073\067\045\073\045\077\045\160\062\045\164\073\064"
	+ "\045\073\045\077\045\160\063\045\164\073\067\045\073\045\077"
	+ "\045\160\064\045\164\073\065\045\073\045\077\045\160\066\045"
	+ "\164\073\061\045\073\045\077\045\160\067\045\164\073\070\045"
	+ "\073\045\077\045\160\071\045\164\073\061\061\045\073\155\000"
	+ "\063\000\005\000\033\133\065\155\000\064\000\005\000\033\133"
	+ "\061\155\000\105\000\005\000\033\133\067\155\000\135\000\006"
	+ "\000\033\133\061\060\155\000\140\000\004\000\033\133\155\000"
	+ "\143\000\004\000\033\133\155\000\125\000\010\000\033\133\060"
	+ "\073\061\060\155\000\103\000\006\000\033\133\061\061\155\000"
	+ "\112\000\005\000\033\133\067\155\000\116\000\005\000\033\133"
	+ "\064\155\000\000\000\077\000\053\020\054\021\055\030\056\031"
	+ "\060\333\140\004\141\261\146\370\147\361\150\260\152\331\153"
	+ "\277\154\332\155\300\156\305\157\176\160\304\161\304\162\304"
	+ "\163\137\164\303\165\264\166\301\167\302\170\263\171\363\172"
	+ "\362\173\343\174\330\175\234\176\376\000\123\000\006\000\033"
	+ "\133\061\060\155\000\061\000\006\000\033\133\061\061\155\000"
	+ "\063\001\011\000\033\133\045\160\061\045\144\104\000\056\001"
	+ "\011\000\033\133\045\160\061\045\144\102\000\065\001\011\000"
	+ "\033\133\045\160\061\045\144\103\000\070\001\011\000\033\133"
	+ "\045\160\061\045\144\101\000\054\001\011\000\033\133\045\160"
	+ "\061\045\144\120\000\055\001\011\000\033\133\045\160\061\045"
	+ "\144\115\000\122\000\011\000\033\133\045\160\061\045\144\130"
	+ "\000\022\000\005\000\033\133\061\113\000\027\000\013\000\033"
	+ "\133\045\151\045\160\061\045\144\107\000\166\001\004\000\033"
	+ "\133\111\000\060\001\011\000\033\133\045\160\061\045\144\100"
	+ "\000\062\001\011\000\033\133\045\160\061\045\144\114\000\061"
	+ "\001\011\000\033\133\045\160\061\045\144\123\000\173\000\002"
	+ "\000\010\000\175\000\004\000\033\133\132\000\326\000\004\000"
	+ "\033\133\104\000\212\000\004\000\033\133\102\000\351\000\004"
	+ "\000\033\133\103\000\015\001\004\000\033\133\101\000\324\000"
	+ "\004\000\033\133\114\000\102\001\005\000\033\133\064\151\000"
	+ "\103\001\005\000\033\133\065\151\000\047\001\005\000\015\033"
	+ "\133\123\000\107\001\024\000\045\160\061\045\143\033\133\045"
	+ "\160\062\045\173\061\175\045\055\045\144\142\000\067\001\011"
	+ "\000\033\133\045\160\061\045\144\124\000\125\001\004\000\033"
	+ "\050\102\000\126\001\004\000\033\051\102\000\127\001\004\000"
	+ "\033\052\102\000\130\001\004\000\033\053\102\000\017\000\005"
	+ "\000\033\133\063\147\000\117\001\013\000\033\133\045\151\045"
	+ "\160\061\045\144\144\000\003\000\002\000\007\000\002\000\004"
	+ "\000\033\133\132\000\021\000\007\000\033\133\110\033\133\112"
	+ "\000\007\000\002\000\015\000\036\000\004\000\033\133\104\000"
	+ "\033\000\004\000\033\133\102\000\041\000\004\000\033\133\103"
	+ "\000\032\000\021\000\033\133\045\151\045\160\061\045\144\073"
	+ "\045\160\062\045\144\110\000\043\000\004\000\033\133\101\000"
	+ "\047\000\004\000\033\133\120\000\050\000\004\000\033\133\115"
	+ "\000\024\000\004\000\033\133\112\000\023\000\004\000\033\133"
	+ "\113\000\034\000\004\000\033\133\110\000\153\001\003\000\033"
	+ "\110\000\166\000\004\000\033\133\114\000\122\001\002\000\012"
	+ "\000\323\000\004\000\033\133\110\000\020\000\002\000\003\000"
	+ "\101\130\000\146\001\003\000\142\163\000\146\001",
	+ 942
	+ },
	+ {
	+ "dumb",
	+ "\001\005\000\144\165\155\142\000\000\000\000\000\005\000\001"
	+ "\000\001\000\001\006\000\001\000\004\000\120\000\032\000\004"
	+ "\000\003\000\002\000\007\000\007\000\002\000\015\000\033\000"
	+ "\002\000\012\000\122\001\002\000\012\000\000\000",
	+ 57
	+ },
	+ {
	+ "rxvt-unicode-256color",
	+ "\001\026\000\162\170\166\164\055\165\156\151\143\157\144\145"
	+ "\055\062\065\066\143\157\154\157\162\000\000\000\000\000\032"
	+ "\000\010\000\003\000\001\001\000\001\002\000\001\012\000\001"
	+ "\026\000\001\027\000\001\011\000\001\044\000\001\026\000\005"
	+ "\000\016\000\000\001\021\000\377\177\004\000\120\000\007\000"
	+ "\010\000\012\000\030\000\053\007\222\000\163\000\136\000\033"
	+ "\135\064\073\045\160\061\045\144\073\162\147\142\072\045\160"
	+ "\062\045\173\062\065\065\175\045\052\045\173\061\060\060\060"
	+ "\175\045\057\045\062\056\062\130\057\045\160\063\045\173\062"
	+ "\065\065\175\045\052\045\173\061\060\060\060\175\045\057\045"
	+ "\062\056\062\130\057\045\160\064\045\173\062\065\065\175\045"
	+ "\052\045\173\061\060\060\060\175\045\057\045\062\056\062\130"
	+ "\033\134\000\051\001\007\000\033\135\061\060\064\007\000\132"
	+ "\001\100\000\033\133\045\077\045\160\061\045\173\070\175\045"
	+ "\074\045\164\064\045\160\061\045\144\045\145\045\160\061\045"
	+ "\173\061\066\175\045\074\045\164\061\060\045\160\061\045\173"
	+ "\070\175\045\055\045\144\045\145\064\070\073\065\073\045\160"
	+ "\061\045\144\045\073\155\000\133\001\077\000\033\133\045\077"
	+ "\045\160\061\045\173\070\175\045\074\045\164\063\045\160\061"
	+ "\045\144\045\145\045\160\061\045\173\061\066\175\045\074\045"
	+ "\164\071\045\160\061\045\173\070\175\045\055\045\144\045\145"
	+ "\063\070\073\065\073\045\160\061\045\144\045\073\155\000\027"
	+ "\000\013\000\033\133\045\151\045\160\061\045\144\107\000\221"
	+ "\000\006\000\033\133\062\061\176\000\125\000\005\000\033\133"
	+ "\155\017\000\117\001\013\000\033\133\045\151\045\160\061\045"
	+ "\144\144\000\000\000\063\000\140\140\141\141\146\146\147\147"
	+ "\152\152\153\153\154\154\155\155\156\156\157\157\160\160\161"
	+ "\161\162\162\163\163\164\164\165\165\166\166\167\167\170\170"
	+ "\171\171\172\172\173\173\174\174\175\175\176\176\000\003\000"
	+ "\002\000\007\000\063\000\005\000\033\133\065\155\000\064\000"
	+ "\005\000\033\133\061\155\000\035\000\007\000\033\133\077\062"
	+ "\065\154\000\021\000\010\000\033\133\110\033\133\062\112\000"
	+ "\040\000\007\000\033\133\077\062\065\150\000\007\000\002\000"
	+ "\015\000\014\000\021\000\033\133\045\151\045\160\061\045\144"
	+ "\073\045\160\062\045\144\162\000\063\001\011\000\033\133\045"
	+ "\160\061\045\144\104\000\036\000\002\000\010\000\056\001\011"
	+ "\000\033\133\045\160\061\045\144\102\000\033\000\002\000\012"
	+ "\000\065\001\011\000\033\133\045\160\061\045\144\103\000\041"
	+ "\000\004\000\033\133\103\000\032\000\021\000\033\133\045\151"
	+ "\045\160\061\045\144\073\045\160\062\045\144\110\000\070\001"
	+ "\011\000\033\133\045\160\061\045\144\101\000\043\000\004\000"
	+ "\033\133\101\000\055\001\011\000\033\133\045\160\061\045\144"
	+ "\115\000\050\000\004\000\033\133\115\000\024\000\004\000\033"
	+ "\133\112\000\023\000\004\000\033\133\113\000\022\000\005\000"
	+ "\033\133\061\113\000\057\000\007\000\033\050\102\033\051\060"
	+ "\000\150\000\022\000\033\133\077\065\150\044\074\061\060\060"
	+ "\057\076\033\133\077\065\154\000\034\000\004\000\033\133\110"
	+ "\000\166\001\002\000\011\000\153\001\003\000\033\110\000\060"
	+ "\001\011\000\033\133\045\160\061\045\144\100\000\165\000\004"
	+ "\000\033\133\100\000\062\001\011\000\033\133\045\160\061\045"
	+ "\144\114\000\166\000\004\000\033\133\114\000\122\001\002\000"
	+ "\012\000\156\000\016\000\033\133\077\064\067\154\033\075\033"
	+ "\133\077\061\154\000\157\000\042\000\033\133\162\033\133\155"
	+ "\033\133\062\112\033\133\110\033\133\077\067\150\033\133\077"
	+ "\061\073\063\073\064\073\066\154\033\133\064\154\000\173\000"
	+ "\002\000\010\000\175\000\004\000\033\133\132\000\332\000\004"
	+ "\000\033\133\115\000\116\001\003\000\033\070\000\105\000\005"
	+ "\000\033\133\067\155\000\123\001\003\000\033\115\000\123\000"
	+ "\002\000\017\000\126\000\015\000\033\133\062\112\033\133\077"
	+ "\064\067\154\033\070\000\131\000\005\000\033\133\064\154\000"
	+ "\016\001\003\000\033\076\000\140\000\006\000\033\133\062\067"
	+ "\155\000\143\000\006\000\033\133\062\064\155\000\112\001\041"
	+ "\000\033\076\033\133\061\073\063\073\064\073\065\073\066\154"
	+ "\033\133\077\067\150\033\133\155\033\133\162\033\133\062\112"
	+ "\033\133\110\000\113\001\062\000\033\133\162\033\133\155\033"
	+ "\133\062\112\033\133\110\033\133\077\067\150\033\133\077\061"
	+ "\073\063\073\064\073\066\154\033\133\064\154\033\076\033\133"
	+ "\077\061\060\060\060\154\033\133\077\062\065\150\000\125\001"
	+ "\004\000\033\050\102\000\126\001\004\000\033\050\060\000\120"
	+ "\001\003\000\033\067\000\134\001\103\000\033\133\060\045\077"
	+ "\045\160\066\045\164\073\061\045\073\045\077\045\160\062\045"
	+ "\164\073\064\045\073\045\077\045\160\061\045\160\063\045\174"
	+ "\045\164\073\067\045\073\045\077\045\160\064\045\164\073\065"
	+ "\045\073\155\045\077\045\160\071\045\164\016\045\145\017\045"
	+ "\073\000\061\000\002\000\016\000\065\000\011\000\033\067\033"
	+ "\133\077\064\067\150\000\073\000\005\000\033\133\064\150\000"
	+ "\017\001\003\000\033\075\000\112\000\005\000\033\133\067\155"
	+ "\000\116\000\005\000\033\133\064\155\000\017\000\005\000\033"
	+ "\133\063\147\000\202\001\010\000\033\133\077\061\073\062\143"
	+ "\000\200\001\013\000\033\133\045\151\045\144\073\045\144\122"
	+ "\000\201\001\005\000\033\133\066\156\000\203\001\004\000\033"
	+ "\133\143\000\360\000\005\000\033\133\063\044\000\363\000\005"
	+ "\000\033\133\070\044\000\371\000\005\000\033\133\067\044\000"
	+ "\372\000\005\000\033\133\062\044\000\373\000\004\000\033\133"
	+ "\144\000\376\000\005\000\033\133\066\044\000\000\001\005\000"
	+ "\033\133\065\044\000\005\001\004\000\033\133\143\000\326\000"
	+ "\004\000\033\133\104\000\212\000\004\000\033\133\102\000\351"
	+ "\000\004\000\033\133\103\000\015\001\004\000\033\133\101\000"
	+ "\210\000\005\000\033\133\063\176\000\216\000\005\000\033\133"
	+ "\070\136\000\214\000\005\000\033\133\070\176\000\222\000\006"
	+ "\000\033\133\061\061\176\000\233\000\006\000\033\133\062\061"
	+ "\176\000\234\000\006\000\033\133\062\063\176\000\235\000\006"
	+ "\000\033\133\062\064\176\000\236\000\006\000\033\133\062\065"
	+ "\176\000\237\000\006\000\033\133\062\066\176\000\240\000\006"
	+ "\000\033\133\062\070\176\000\241\000\006\000\033\133\062\071"
	+ "\176\000\242\000\006\000\033\133\063\061\176\000\243\000\006"
	+ "\000\033\133\063\062\176\000\244\000\006\000\033\133\063\063"
	+ "\176\000\223\000\006\000\033\133\061\062\176\000\245\000\006"
	+ "\000\033\133\063\064\176\000\246\000\006\000\033\133\062\063"
	+ "\044\000\247\000\006\000\033\133\062\064\044\000\250\000\006"
	+ "\000\033\133\061\061\136\000\251\000\006\000\033\133\061\062"
	+ "\136\000\252\000\006\000\033\133\061\063\136\000\253\000\006"
	+ "\000\033\133\061\064\136\000\254\000\006\000\033\133\061\065"
	+ "\136\000\255\000\006\000\033\133\061\067\136\000\256\000\006"
	+ "\000\033\133\061\070\136\000\224\000\006\000\033\133\061\063"
	+ "\176\000\257\000\006\000\033\133\061\071\136\000\260\000\006"
	+ "\000\033\133\062\060\136\000\261\000\006\000\033\133\062\061"
	+ "\136\000\262\000\006\000\033\133\062\063\136\000\263\000\006"
	+ "\000\033\133\062\064\136\000\264\000\006\000\033\133\062\065"
	+ "\136\000\265\000\006\000\033\133\062\066\136\000\266\000\006"
	+ "\000\033\133\062\070\136\000\267\000\006\000\033\133\062\071"
	+ "\136\000\270\000\006\000\033\133\063\061\136\000\225\000\006"
	+ "\000\033\133\061\064\176\000\271\000\006\000\033\133\063\062"
	+ "\136\000\272\000\006\000\033\133\063\063\136\000\273\000\006"
	+ "\000\033\133\063\064\136\000\274\000\006\000\033\133\062\063"
	+ "\100\000\275\000\006\000\033\133\062\064\100\000\226\000\006"
	+ "\000\033\133\061\065\176\000\227\000\006\000\033\133\061\067"
	+ "\176\000\230\000\006\000\033\133\061\070\176\000\231\000\006"
	+ "\000\033\133\061\071\176\000\232\000\006\000\033\133\062\060"
	+ "\176\000\321\000\005\000\033\133\061\176\000\323\000\005\000"
	+ "\033\133\067\176\000\324\000\005\000\033\133\062\176\000\366"
	+ "\000\004\000\033\133\141\000\335\000\005\000\033\133\066\176"
	+ "\000\340\000\005\000\033\133\065\176\000\002\001\004\000\033"
	+ "\133\142\000\362\000\005\000\033\133\064\176\000\170\000\004"
	+ "\000\033\117\167\000\171\000\004\000\033\117\171\000\172\000"
	+ "\004\000\033\117\165\000\176\000\004\000\033\117\161\000\177"
	+ "\000\004\000\033\117\163\000\215\000\004\000\033\117\115\000"
	+ "\052\001\011\000\033\133\063\071\073\064\071\155\000\133\001"
	+ "\031\000\003\000\142\163\000\146\001\003\000\130\124\000\146"
	+ "\001\005\000\153\104\103\065\000\163\005\000\033\133\063\136"
	+ "\000\005\000\153\104\103\066\000\163\005\000\033\133\063\100"
	+ "\000\004\000\153\104\116\000\163\004\000\033\133\142\000\005"
	+ "\000\153\104\116\065\000\163\004\000\033\117\142\000\006\000"
	+ "\153\105\116\104\065\000\163\005\000\033\133\070\136\000\006"
	+ "\000\153\105\116\104\066\000\163\005\000\033\133\070\100\000"
	+ "\006\000\153\110\117\115\065\000\163\005\000\033\133\067\136"
	+ "\000\006\000\153\110\117\115\066\000\163\005\000\033\133\067"
	+ "\100\000\005\000\153\111\103\065\000\163\005\000\033\133\062"
	+ "\136\000\005\000\153\111\103\066\000\163\005\000\033\133\062"
	+ "\100\000\006\000\153\114\106\124\065\000\163\004\000\033\117"
	+ "\144\000\006\000\153\116\130\124\065\000\163\005\000\033\133"
	+ "\066\136\000\006\000\153\116\130\124\066\000\163\005\000\033"
	+ "\133\066\100\000\006\000\153\120\122\126\065\000\163\005\000"
	+ "\033\133\065\136\000\006\000\153\120\122\126\066\000\163\005"
	+ "\000\033\133\065\100\000\006\000\153\122\111\124\065\000\163"
	+ "\004\000\033\117\143\000\004\000\153\125\120\000\163\004\000"
	+ "\033\133\141\000\005\000\153\125\120\065\000\163\004\000\033"
	+ "\117\141\000\004\000\153\141\062\000\163\004\000\033\117\170"
	+ "\000\004\000\153\142\061\000\163\004\000\033\117\164\000\004"
	+ "\000\153\142\063\000\163\004\000\033\117\166\000\004\000\153"
	+ "\143\062\000\163\004\000\033\117\162\000\003\000\101\130\000"
	+ "\146\001",
	+ 2267
	+ },
	+ {
	+ "screen",
	+ "\001\007\000\163\143\162\145\145\156\000\000\000\000\000\021"
	+ "\000\005\000\001\000\001\016\000\001\026\000\001\027\000\001"
	+ "\011\000\001\032\000\006\000\016\000\010\000\004\000\120\000"
	+ "\007\000\010\000\012\000\030\000\025\000\376\377\021\000\100"
	+ "\000\330\003\127\000\000\000\101\000\053\053\054\054\055\055"
	+ "\056\056\060\060\140\140\141\141\146\146\147\147\150\150\151"
	+ "\151\152\152\153\153\154\154\155\155\156\156\157\157\160\160"
	+ "\161\161\162\162\163\163\164\164\165\165\166\166\167\167\170"
	+ "\170\171\171\172\172\173\173\174\174\175\175\176\176\000\003"
	+ "\000\002\000\007\000\063\000\005\000\033\133\065\155\000\064"
	+ "\000\005\000\033\133\061\155\000\002\000\004\000\033\133\132"
	+ "\000\035\000\007\000\033\133\077\062\065\154\000\021\000\007"
	+ "\000\033\133\110\033\133\112\000\040\000\014\000\033\133\063"
	+ "\064\150\033\133\077\062\065\150\000\007\000\002\000\015\000"
	+ "\014\000\021\000\033\133\045\151\045\160\061\045\144\073\045"
	+ "\160\062\045\144\162\000\063\001\011\000\033\133\045\160\061"
	+ "\045\144\104\000\036\000\002\000\010\000\056\001\011\000\033"
	+ "\133\045\160\061\045\144\102\000\033\000\002\000\012\000\065"
	+ "\001\011\000\033\133\045\160\061\045\144\103\000\041\000\004"
	+ "\000\033\133\103\000\032\000\021\000\033\133\045\151\045\160"
	+ "\061\045\144\073\045\160\062\045\144\110\000\070\001\011\000"
	+ "\033\133\045\160\061\045\144\101\000\043\000\003\000\033\115"
	+ "\000\044\000\006\000\033\133\063\064\154\000\054\001\011\000"
	+ "\033\133\045\160\061\045\144\120\000\047\000\004\000\033\133"
	+ "\120\000\067\000\005\000\033\133\062\155\000\055\001\011\000"
	+ "\033\133\045\160\061\045\144\115\000\050\000\004\000\033\133"
	+ "\115\000\024\000\004\000\033\133\112\000\023\000\004\000\033"
	+ "\133\113\000\022\000\005\000\033\133\061\113\000\057\000\007"
	+ "\000\033\050\102\033\051\060\000\150\000\003\000\033\147\000"
	+ "\034\000\004\000\033\133\110\000\166\001\002\000\011\000\153"
	+ "\001\003\000\033\110\000\060\001\011\000\033\133\045\160\061"
	+ "\045\144\100\000\062\001\011\000\033\133\045\160\061\045\144"
	+ "\114\000\166\000\004\000\033\133\114\000\122\001\002\000\012"
	+ "\000\157\000\004\000\033\051\060\000\173\000\002\000\010\000"
	+ "\175\000\004\000\033\133\132\000\326\000\004\000\033\117\104"
	+ "\000\212\000\004\000\033\117\102\000\351\000\004\000\033\117"
	+ "\103\000\015\001\004\000\033\117\101\000\210\000\005\000\033"
	+ "\133\063\176\000\214\000\005\000\033\133\064\176\000\222\000"
	+ "\004\000\033\117\120\000\233\000\006\000\033\133\062\061\176"
	+ "\000\234\000\006\000\033\133\062\063\176\000\235\000\006\000"
	+ "\033\133\062\064\176\000\223\000\004\000\033\117\121\000\224"
	+ "\000\004\000\033\117\122\000\225\000\004\000\033\117\123\000"
	+ "\226\000\006\000\033\133\061\065\176\000\227\000\006\000\033"
	+ "\133\061\067\176\000\230\000\006\000\033\133\061\070\176\000"
	+ "\231\000\006\000\033\133\061\071\176\000\232\000\006\000\033"
	+ "\133\062\060\176\000\323\000\005\000\033\133\061\176\000\324"
	+ "\000\005\000\033\133\062\176\000\332\000\004\000\033\133\115"
	+ "\000\335\000\005\000\033\133\066\176\000\340\000\005\000\033"
	+ "\133\065\176\000\047\001\003\000\033\105\000\116\001\003\000"
	+ "\033\070\000\105\000\005\000\033\133\067\155\000\123\001\003"
	+ "\000\033\115\000\123\000\002\000\017\000\126\000\011\000\033"
	+ "\133\077\061\060\064\071\154\000\131\000\005\000\033\133\064"
	+ "\154\000\016\001\010\000\033\133\077\061\154\033\076\000\140"
	+ "\000\006\000\033\133\062\063\155\000\143\000\006\000\033\133"
	+ "\062\064\155\000\113\001\021\000\033\143\033\133\077\061\060"
	+ "\060\060\154\033\133\077\062\065\150\000\120\001\003\000\033"
	+ "\067\000\134\001\124\000\033\133\060\045\077\045\160\066\045"
	+ "\164\073\061\045\073\045\077\045\160\061\045\164\073\063\045"
	+ "\073\045\077\045\160\062\045\164\073\064\045\073\045\077\045"
	+ "\160\063\045\164\073\067\045\073\045\077\045\160\064\045\164"
	+ "\073\065\045\073\045\077\045\160\065\045\164\073\062\045\073"
	+ "\155\045\077\045\160\071\045\164\016\045\145\017\045\073\000"
	+ "\125\000\005\000\033\133\155\017\000\061\000\002\000\016\000"
	+ "\065\000\011\000\033\133\077\061\060\064\071\150\000\073\000"
	+ "\005\000\033\133\064\150\000\017\001\010\000\033\133\077\061"
	+ "\150\033\075\000\112\000\005\000\033\133\063\155\000\116\000"
	+ "\005\000\033\133\064\155\000\017\000\005\000\033\133\063\147"
	+ "\000\052\001\011\000\033\133\063\071\073\064\071\155\000\132"
	+ "\001\012\000\033\133\064\045\160\061\045\144\155\000\133\001"
	+ "\012\000\033\133\063\045\160\061\045\144\155\000\102\000\007"
	+ "\000\003\000\142\163\000\146\001\003\000\160\164\000\146\001"
	+ "\003\000\107\060\000\146\001\003\000\125\070\000\156\001\000"
	+ "\003\000\105\060\000\163\004\000\033\050\102\000\003\000\123"
	+ "\060\000\163\010\000\033\050\045\160\061\045\143\000\003\000"
	+ "\101\130\000\146\001",
	+ 1115
	+ },
	+ {
	+ "screen-256color",
	+ "\001\020\000\163\143\162\145\145\156\055\062\065\066\143\157"
	+ "\154\157\162\000\000\000\000\000\021\000\005\000\001\000\001"
	+ "\016\000\001\026\000\001\027\000\001\011\000\001\026\000\005"
	+ "\000\016\000\000\001\021\000\377\177\004\000\120\000\007\000"
	+ "\010\000\012\000\030\000\103\004\127\000\132\001\100\000\033"
	+ "\133\045\077\045\160\061\045\173\070\175\045\074\045\164\064"
	+ "\045\160\061\045\144\045\145\045\160\061\045\173\061\066\175"
	+ "\045\074\045\164\061\060\045\160\061\045\173\070\175\045\055"
	+ "\045\144\045\145\064\070\073\065\073\045\160\061\045\144\045"
	+ "\073\155\000\133\001\077\000\033\133\045\077\045\160\061\045"
	+ "\173\070\175\045\074\045\164\063\045\160\061\045\144\045\145"
	+ "\045\160\061\045\173\061\066\175\045\074\045\164\071\045\160"
	+ "\061\045\173\070\175\045\055\045\144\045\145\063\070\073\065"
	+ "\073\045\160\061\045\144\045\073\155\000\000\000\101\000\053"
	+ "\053\054\054\055\055\056\056\060\060\140\140\141\141\146\146"
	+ "\147\147\150\150\151\151\152\152\153\153\154\154\155\155\156"
	+ "\156\157\157\160\160\161\161\162\162\163\163\164\164\165\165"
	+ "\166\166\167\167\170\170\171\171\172\172\173\173\174\174\175"
	+ "\175\176\176\000\003\000\002\000\007\000\063\000\005\000\033"
	+ "\133\065\155\000\064\000\005\000\033\133\061\155\000\002\000"
	+ "\004\000\033\133\132\000\035\000\007\000\033\133\077\062\065"
	+ "\154\000\021\000\007\000\033\133\110\033\133\112\000\040\000"
	+ "\014\000\033\133\063\064\150\033\133\077\062\065\150\000\007"
	+ "\000\002\000\015\000\014\000\021\000\033\133\045\151\045\160"
	+ "\061\045\144\073\045\160\062\045\144\162\000\063\001\011\000"
	+ "\033\133\045\160\061\045\144\104\000\036\000\002\000\010\000"
	+ "\056\001\011\000\033\133\045\160\061\045\144\102\000\033\000"
	+ "\002\000\012\000\065\001\011\000\033\133\045\160\061\045\144"
	+ "\103\000\041\000\004\000\033\133\103\000\032\000\021\000\033"
	+ "\133\045\151\045\160\061\045\144\073\045\160\062\045\144\110"
	+ "\000\070\001\011\000\033\133\045\160\061\045\144\101\000\043"
	+ "\000\003\000\033\115\000\044\000\006\000\033\133\063\064\154"
	+ "\000\054\001\011\000\033\133\045\160\061\045\144\120\000\047"
	+ "\000\004\000\033\133\120\000\067\000\005\000\033\133\062\155"
	+ "\000\055\001\011\000\033\133\045\160\061\045\144\115\000\050"
	+ "\000\004\000\033\133\115\000\024\000\004\000\033\133\112\000"
	+ "\023\000\004\000\033\133\113\000\022\000\005\000\033\133\061"
	+ "\113\000\057\000\007\000\033\050\102\033\051\060\000\150\000"
	+ "\003\000\033\147\000\034\000\004\000\033\133\110\000\166\001"
	+ "\002\000\011\000\153\001\003\000\033\110\000\060\001\011\000"
	+ "\033\133\045\160\061\045\144\100\000\062\001\011\000\033\133"
	+ "\045\160\061\045\144\114\000\166\000\004\000\033\133\114\000"
	+ "\122\001\002\000\012\000\157\000\004\000\033\051\060\000\173"
	+ "\000\002\000\010\000\175\000\004\000\033\133\132\000\326\000"
	+ "\004\000\033\117\104\000\212\000\004\000\033\117\102\000\351"
	+ "\000\004\000\033\117\103\000\015\001\004\000\033\117\101\000"
	+ "\210\000\005\000\033\133\063\176\000\214\000\005\000\033\133"
	+ "\064\176\000\222\000\004\000\033\117\120\000\233\000\006\000"
	+ "\033\133\062\061\176\000\234\000\006\000\033\133\062\063\176"
	+ "\000\235\000\006\000\033\133\062\064\176\000\223\000\004\000"
	+ "\033\117\121\000\224\000\004\000\033\117\122\000\225\000\004"
	+ "\000\033\117\123\000\226\000\006\000\033\133\061\065\176\000"
	+ "\227\000\006\000\033\133\061\067\176\000\230\000\006\000\033"
	+ "\133\061\070\176\000\231\000\006\000\033\133\061\071\176\000"
	+ "\232\000\006\000\033\133\062\060\176\000\323\000\005\000\033"
	+ "\133\061\176\000\324\000\005\000\033\133\062\176\000\332\000"
	+ "\004\000\033\133\115\000\335\000\005\000\033\133\066\176\000"
	+ "\340\000\005\000\033\133\065\176\000\047\001\003\000\033\105"
	+ "\000\116\001\003\000\033\070\000\105\000\005\000\033\133\067"
	+ "\155\000\123\001\003\000\033\115\000\123\000\002\000\017\000"
	+ "\126\000\011\000\033\133\077\061\060\064\071\154\000\131\000"
	+ "\005\000\033\133\064\154\000\016\001\010\000\033\133\077\061"
	+ "\154\033\076\000\140\000\006\000\033\133\062\063\155\000\143"
	+ "\000\006\000\033\133\062\064\155\000\113\001\021\000\033\143"
	+ "\033\133\077\061\060\060\060\154\033\133\077\062\065\150\000"
	+ "\120\001\003\000\033\067\000\134\001\124\000\033\133\060\045"
	+ "\077\045\160\066\045\164\073\061\045\073\045\077\045\160\061"
	+ "\045\164\073\063\045\073\045\077\045\160\062\045\164\073\064"
	+ "\045\073\045\077\045\160\063\045\164\073\067\045\073\045\077"
	+ "\045\160\064\045\164\073\065\045\073\045\077\045\160\065\045"
	+ "\164\073\062\045\073\155\045\077\045\160\071\045\164\016\045"
	+ "\145\017\045\073\000\125\000\005\000\033\133\155\017\000\061"
	+ "\000\002\000\016\000\065\000\011\000\033\133\077\061\060\064"
	+ "\071\150\000\073\000\005\000\033\133\064\150\000\017\001\010"
	+ "\000\033\133\077\061\150\033\075\000\112\000\005\000\033\133"
	+ "\063\155\000\116\000\005\000\033\133\064\155\000\017\000\005"
	+ "\000\033\133\063\147\000\052\001\011\000\033\133\063\071\073"
	+ "\064\071\155\000\102\000\007\000\003\000\142\163\000\146\001"
	+ "\003\000\160\164\000\146\001\003\000\107\060\000\146\001\003"
	+ "\000\125\070\000\156\001\000\003\000\105\060\000\163\004\000"
	+ "\033\050\102\000\003\000\123\060\000\163\010\000\033\050\045"
	+ "\160\061\045\143\000\003\000\101\130\000\146\001",
	+ 1227
	+ },
	+ {
	+ "st",
	+ "\001\003\000\163\164\000\000\000\000\000\027\000\007\000\001"
	+ "\000\001\002\000\001\020\000\001\026\000\001\027\000\001\032"
	+ "\000\001\011\000\001\026\000\005\000\016\000\010\000\004\000"
	+ "\120\000\007\000\010\000\012\000\030\000\021\000\100\000\134"
	+ "\010\261\000\000\000\101\000\053\103\054\104\055\101\056\102"
	+ "\060\105\140\140\141\141\146\146\147\147\150\106\151\107\152"
	+ "\152\153\153\154\154\155\155\156\156\157\157\160\160\161\161"
	+ "\162\162\163\163\164\164\165\165\166\166\167\167\170\170\171"
	+ "\171\172\172\173\173\174\174\175\175\176\176\000\003\000\002"
	+ "\000\007\000\063\000\005\000\033\133\065\155\000\064\000\005"
	+ "\000\033\133\061\155\000\002\000\004\000\033\133\132\000\035"
	+ "\000\007\000\033\133\077\062\065\154\000\021\000\010\000\033"
	+ "\133\110\033\133\062\112\000\040\000\015\000\033\133\077\061"
	+ "\062\154\033\133\077\062\065\150\000\007\000\002\000\015\000"
	+ "\014\000\021\000\033\133\045\151\045\160\061\045\144\073\045"
	+ "\160\062\045\144\162\000\063\001\011\000\033\133\045\160\061"
	+ "\045\144\104\000\036\000\002\000\010\000\056\001\011\000\033"
	+ "\133\045\160\061\045\144\102\000\033\000\002\000\012\000\065"
	+ "\001\011\000\033\133\045\160\061\045\144\103\000\041\000\004"
	+ "\000\033\133\103\000\032\000\021\000\033\133\045\151\045\160"
	+ "\061\045\144\073\045\160\062\045\144\110\000\070\001\011\000"
	+ "\033\133\045\160\061\045\144\101\000\043\000\004\000\033\133"
	+ "\101\000\044\000\007\000\033\133\077\062\065\150\000\054\001"
	+ "\011\000\033\133\045\160\061\045\144\120\000\047\000\004\000"
	+ "\033\133\120\000\055\001\011\000\033\133\045\160\061\045\144"
	+ "\115\000\050\000\004\000\033\133\115\000\122\000\011\000\033"
	+ "\133\045\160\061\045\144\130\000\024\000\004\000\033\133\112"
	+ "\000\023\000\004\000\033\133\113\000\022\000\005\000\033\133"
	+ "\061\113\000\057\000\004\000\033\051\060\000\150\000\022\000"
	+ "\033\133\077\065\150\044\074\061\060\060\057\076\033\133\077"
	+ "\065\154\000\152\000\002\000\007\000\034\000\004\000\033\133"
	+ "\110\000\027\000\013\000\033\133\045\151\045\160\061\045\144"
	+ "\107\000\166\001\002\000\011\000\153\001\003\000\033\110\000"
	+ "\060\001\011\000\033\133\045\160\061\045\144\100\000\062\001"
	+ "\011\000\033\133\045\160\061\045\144\114\000\166\000\004\000"
	+ "\033\133\114\000\122\001\002\000\012\000\061\001\011\000\033"
	+ "\133\045\160\061\045\144\123\000\110\000\005\000\033\133\070"
	+ "\155\000\157\000\017\000\033\133\064\154\033\076\033\133\077"
	+ "\061\060\063\064\154\000\360\000\007\000\033\133\063\073\062"
	+ "\176\000\363\000\007\000\033\133\061\073\062\106\000\371\000"
	+ "\007\000\033\133\061\073\062\110\000\372\000\007\000\033\133"
	+ "\062\073\062\176\000\373\000\007\000\033\133\061\073\062\104"
	+ "\000\376\000\007\000\033\133\066\073\062\176\000\000\001\007"
	+ "\000\033\133\065\073\062\176\000\005\001\007\000\033\133\061"
	+ "\073\062\103\000\170\000\005\000\033\133\061\176\000\171\000"
	+ "\005\000\033\133\065\176\000\172\000\004\000\033\117\165\000"
	+ "\173\000\002\000\177\000\176\000\005\000\033\133\064\176\000"
	+ "\177\000\005\000\033\133\066\176\000\175\000\004\000\033\133"
	+ "\132\000\202\000\007\000\033\133\063\073\065\176\000\326\000"
	+ "\004\000\033\117\104\000\212\000\004\000\033\117\102\000\351"
	+ "\000\004\000\033\117\103\000\015\001\004\000\033\117\101\000"
	+ "\210\000\005\000\033\133\063\176\000\211\000\007\000\033\133"
	+ "\063\073\062\176\000\217\000\007\000\033\133\061\073\065\106"
	+ "\000\216\000\007\000\033\133\061\073\062\106\000\214\000\005"
	+ "\000\033\133\064\176\000\215\000\004\000\033\117\115\000\222"
	+ "\000\004\000\033\117\120\000\233\000\006\000\033\133\062\061"
	+ "\176\000\234\000\006\000\033\133\062\063\176\000\235\000\006"
	+ "\000\033\133\062\064\176\000\236\000\007\000\033\133\061\073"
	+ "\062\120\000\237\000\007\000\033\133\061\073\062\121\000\240"
	+ "\000\007\000\033\133\061\073\062\122\000\241\000\007\000\033"
	+ "\133\061\073\062\123\000\242\000\010\000\033\133\061\065\073"
	+ "\062\176\000\243\000\010\000\033\133\061\067\073\062\176\000"
	+ "\244\000\010\000\033\133\061\070\073\062\176\000\223\000\004"
	+ "\000\033\117\121\000\245\000\010\000\033\133\061\071\073\062"
	+ "\176\000\246\000\010\000\033\133\062\060\073\062\176\000\247"
	+ "\000\010\000\033\133\062\061\073\062\176\000\250\000\010\000"
	+ "\033\133\062\063\073\062\176\000\251\000\010\000\033\133\062"
	+ "\064\073\062\176\000\252\000\007\000\033\133\061\073\065\120"
	+ "\000\253\000\007\000\033\133\061\073\065\121\000\254\000\007"
	+ "\000\033\133\061\073\065\122\000\255\000\007\000\033\133\061"
	+ "\073\065\123\000\256\000\010\000\033\133\061\065\073\065\176"
	+ "\000\224\000\004\000\033\117\122\000\257\000\010\000\033\133"
	+ "\061\067\073\065\176\000\260\000\010\000\033\133\061\070\073"
	+ "\065\176\000\261\000\010\000\033\133\061\071\073\065\176\000"
	+ "\262\000\010\000\033\133\062\060\073\065\176\000\263\000\010"
	+ "\000\033\133\062\061\073\065\176\000\264\000\010\000\033\133"
	+ "\062\063\073\065\176\000\265\000\010\000\033\133\062\064\073"
	+ "\065\176\000\266\000\007\000\033\133\061\073\066\120\000\267"
	+ "\000\007\000\033\133\061\073\066\121\000\270\000\007\000\033"
	+ "\133\061\073\066\122\000\225\000\004\000\033\117\123\000\271"
	+ "\000\007\000\033\133\061\073\066\123\000\272\000\010\000\033"
	+ "\133\061\065\073\066\176\000\273\000\010\000\033\133\061\067"
	+ "\073\066\176\000\274\000\010\000\033\133\061\070\073\066\176"
	+ "\000\275\000\010\000\033\133\061\071\073\066\176\000\276\000"
	+ "\010\000\033\133\062\060\073\066\176\000\277\000\010\000\033"
	+ "\133\062\061\073\066\176\000\300\000\010\000\033\133\062\063"
	+ "\073\066\176\000\301\000\010\000\033\133\062\064\073\066\176"
	+ "\000\302\000\007\000\033\133\061\073\063\120\000\226\000\006"
	+ "\000\033\133\061\065\176\000\303\000\007\000\033\133\061\073"
	+ "\063\121\000\304\000\007\000\033\133\061\073\063\122\000\305"
	+ "\000\007\000\033\133\061\073\063\123\000\306\000\010\000\033"
	+ "\133\061\065\073\063\176\000\307\000\010\000\033\133\061\067"
	+ "\073\063\176\000\310\000\010\000\033\133\061\070\073\063\176"
	+ "\000\311\000\010\000\033\133\061\071\073\063\176\000\312\000"
	+ "\010\000\033\133\062\060\073\063\176\000\313\000\010\000\033"
	+ "\133\062\061\073\063\176\000\314\000\010\000\033\133\062\063"
	+ "\073\063\176\000\227\000\006\000\033\133\061\067\176\000\315"
	+ "\000\010\000\033\133\062\064\073\063\176\000\316\000\007\000"
	+ "\033\133\061\073\064\120\000\317\000\007\000\033\133\061\073"
	+ "\064\121\000\320\000\007\000\033\133\061\073\064\122\000\230"
	+ "\000\006\000\033\133\061\070\176\000\231\000\006\000\033\133"
	+ "\061\071\176\000\232\000\006\000\033\133\062\060\176\000\323"
	+ "\000\005\000\033\133\061\176\000\324\000\005\000\033\133\062"
	+ "\176\000\325\000\007\000\033\133\062\073\065\176\000\366\000"
	+ "\007\000\033\133\061\073\062\102\000\332\000\004\000\033\133"
	+ "\115\000\335\000\005\000\033\133\066\176\000\340\000\005\000"
	+ "\033\133\065\176\000\002\001\007\000\033\133\061\073\062\101"
	+ "\000\213\000\007\000\033\133\062\073\062\176\000\100\001\004"
	+ "\000\033\133\151\000\102\001\005\000\033\133\064\151\000\103"
	+ "\001\005\000\033\133\065\151\000\052\001\011\000\033\133\063"
	+ "\071\073\064\071\155\000\116\001\003\000\033\070\000\105\000"
	+ "\005\000\033\133\067\155\000\123\001\003\000\033\115\000\132"
	+ "\000\006\000\033\133\062\063\155\000\123\000\004\000\033\050"
	+ "\102\000\126\000\011\000\033\133\077\061\060\064\071\154\000"
	+ "\131\000\005\000\033\133\064\154\000\016\001\010\000\033\133"
	+ "\077\061\154\033\076\000\140\000\006\000\033\133\062\067\155"
	+ "\000\143\000\006\000\033\133\062\064\155\000\112\001\003\000"
	+ "\033\143\000\113\001\017\000\033\133\064\154\033\076\033\133"
	+ "\077\061\060\063\064\154\000\120\001\003\000\033\067\000\132"
	+ "\001\012\000\033\133\064\045\160\061\045\144\155\000\133\001"
	+ "\012\000\033\133\063\045\160\061\045\144\155\000\135\001\106"
	+ "\000\033\133\064\045\077\045\160\061\045\173\061\175\045\075"
	+ "\045\164\064\045\145\045\160\061\045\173\063\175\045\075\045"
	+ "\164\066\045\145\045\160\061\045\173\064\175\045\075\045\164"
	+ "\061\045\145\045\160\061\045\173\066\175\045\075\045\164\063"
	+ "\045\145\045\160\061\045\144\045\073\155\000\143\001\106\000"
	+ "\033\133\063\045\077\045\160\061\045\173\061\175\045\075\045"
	+ "\164\064\045\145\045\160\061\045\173\063\175\045\075\045\164"
	+ "\066\045\145\045\160\061\045\173\064\175\045\075\045\164\061"
	+ "\045\145\045\160\061\045\173\066\175\045\075\045\164\063\045"
	+ "\145\045\160\061\045\144\045\073\155\000\134\001\122\000\045"
	+ "\077\045\160\071\045\164\033\050\060\045\145\033\050\102\045"
	+ "\073\033\133\060\045\077\045\160\066\045\164\073\061\045\073"
	+ "\045\077\045\160\062\045\164\073\064\045\073\045\077\045\160"
	+ "\061\045\160\063\045\174\045\164\073\067\045\073\045\077\045"
	+ "\160\064\045\164\073\065\045\073\045\077\045\160\067\045\164"
	+ "\073\070\045\073\155\000\125\000\005\000\033\133\060\155\000"
	+ "\074\000\005\000\033\133\063\155\000\061\000\004\000\033\050"
	+ "\060\000\065\000\011\000\033\133\077\061\060\064\071\150\000"
	+ "\073\000\005\000\033\133\064\150\000\017\001\010\000\033\133"
	+ "\077\061\150\033\075\000\112\000\005\000\033\133\067\155\000"
	+ "\116\000\005\000\033\133\064\155\000\017\000\005\000\033\133"
	+ "\063\147\000\170\001\005\000\033\135\060\073\000\200\001\013"
	+ "\000\033\133\045\151\045\144\073\045\144\122\000\201\001\005"
	+ "\000\033\133\066\156\000\202\001\010\000\033\133\077\061\073"
	+ "\062\143\000\203\001\004\000\033\133\143\000\117\001\013\000"
	+ "\033\133\045\151\045\160\061\045\144\144\000\060\000\004\000"
	+ "\003\000\124\143\000\146\001\003\000\130\124\000\146\001\003"
	+ "\000\123\145\000\163\006\000\033\133\062\040\161\000\003\000"
	+ "\123\163\000\163\012\000\033\133\045\160\061\045\144\040\161"
	+ "\000",
	+ 2251
	+ },
	+ {
	+ "tmux",
	+ "\001\005\000\164\155\165\170\000\000\000\000\000\024\000\006"
	+ "\000\020\000\001\001\000\001\016\000\001\026\000\001\027\000"
	+ "\001\011\000\001\026\000\005\000\016\000\010\000\004\000\120"
	+ "\000\007\000\010\000\012\000\030\000\021\000\100\000\303\006"
	+ "\231\000\132\000\006\000\033\133\062\063\155\000\140\000\006"
	+ "\000\033\133\062\067\155\000\074\000\005\000\033\133\063\155"
	+ "\000\112\000\005\000\033\133\067\155\000\210\000\005\000\033"
	+ "\133\063\176\000\324\000\005\000\033\133\062\176\000\335\000"
	+ "\005\000\033\133\066\176\000\340\000\005\000\033\133\065\176"
	+ "\000\214\000\005\000\033\133\064\176\000\323\000\005\000\033"
	+ "\133\061\176\000\326\000\004\000\033\117\104\000\212\000\004"
	+ "\000\033\117\102\000\351\000\004\000\033\117\103\000\015\001"
	+ "\004\000\033\117\101\000\222\000\004\000\033\117\120\000\233"
	+ "\000\006\000\033\133\062\061\176\000\234\000\006\000\033\133"
	+ "\062\063\176\000\235\000\006\000\033\133\062\064\176\000\236"
	+ "\000\007\000\033\133\061\073\062\120\000\237\000\007\000\033"
	+ "\133\061\073\062\121\000\240\000\007\000\033\133\061\073\062"
	+ "\122\000\241\000\007\000\033\133\061\073\062\123\000\242\000"
	+ "\010\000\033\133\061\065\073\062\176\000\243\000\010\000\033"
	+ "\133\061\067\073\062\176\000\244\000\010\000\033\133\061\070"
	+ "\073\062\176\000\223\000\004\000\033\117\121\000\245\000\010"
	+ "\000\033\133\061\071\073\062\176\000\246\000\010\000\033\133"
	+ "\062\060\073\062\176\000\247\000\010\000\033\133\062\061\073"
	+ "\062\176\000\250\000\010\000\033\133\062\063\073\062\176\000"
	+ "\251\000\010\000\033\133\062\064\073\062\176\000\252\000\007"
	+ "\000\033\133\061\073\065\120\000\253\000\007\000\033\133\061"
	+ "\073\065\121\000\254\000\007\000\033\133\061\073\065\122\000"
	+ "\255\000\007\000\033\133\061\073\065\123\000\256\000\010\000"
	+ "\033\133\061\065\073\065\176\000\224\000\004\000\033\117\122"
	+ "\000\257\000\010\000\033\133\061\067\073\065\176\000\260\000"
	+ "\010\000\033\133\061\070\073\065\176\000\261\000\010\000\033"
	+ "\133\061\071\073\065\176\000\262\000\010\000\033\133\062\060"
	+ "\073\065\176\000\263\000\010\000\033\133\062\061\073\065\176"
	+ "\000\264\000\010\000\033\133\062\063\073\065\176\000\265\000"
	+ "\010\000\033\133\062\064\073\065\176\000\266\000\007\000\033"
	+ "\133\061\073\066\120\000\267\000\007\000\033\133\061\073\066"
	+ "\121\000\270\000\007\000\033\133\061\073\066\122\000\225\000"
	+ "\004\000\033\117\123\000\271\000\007\000\033\133\061\073\066"
	+ "\123\000\272\000\010\000\033\133\061\065\073\066\176\000\273"
	+ "\000\010\000\033\133\061\067\073\066\176\000\274\000\010\000"
	+ "\033\133\061\070\073\066\176\000\275\000\010\000\033\133\061"
	+ "\071\073\066\176\000\276\000\010\000\033\133\062\060\073\066"
	+ "\176\000\277\000\010\000\033\133\062\061\073\066\176\000\300"
	+ "\000\010\000\033\133\062\063\073\066\176\000\301\000\010\000"
	+ "\033\133\062\064\073\066\176\000\302\000\007\000\033\133\061"
	+ "\073\063\120\000\226\000\006\000\033\133\061\065\176\000\303"
	+ "\000\007\000\033\133\061\073\063\121\000\304\000\007\000\033"
	+ "\133\061\073\063\122\000\305\000\007\000\033\133\061\073\063"
	+ "\123\000\306\000\010\000\033\133\061\065\073\063\176\000\307"
	+ "\000\010\000\033\133\061\067\073\063\176\000\310\000\010\000"
	+ "\033\133\061\070\073\063\176\000\311\000\010\000\033\133\061"
	+ "\071\073\063\176\000\312\000\010\000\033\133\062\060\073\063"
	+ "\176\000\313\000\010\000\033\133\062\061\073\063\176\000\314"
	+ "\000\010\000\033\133\062\063\073\063\176\000\227\000\006\000"
	+ "\033\133\061\067\176\000\315\000\010\000\033\133\062\064\073"
	+ "\063\176\000\316\000\007\000\033\133\061\073\064\120\000\317"
	+ "\000\007\000\033\133\061\073\064\121\000\320\000\007\000\033"
	+ "\133\061\073\064\122\000\230\000\006\000\033\133\061\070\176"
	+ "\000\231\000\006\000\033\133\061\071\176\000\232\000\006\000"
	+ "\033\133\062\060\176\000\373\000\007\000\033\133\061\073\062"
	+ "\104\000\005\001\007\000\033\133\061\073\062\103\000\366\000"
	+ "\007\000\033\133\061\073\062\102\000\002\001\007\000\033\133"
	+ "\061\073\062\101\000\360\000\007\000\033\133\063\073\062\176"
	+ "\000\363\000\007\000\033\133\061\073\062\106\000\371\000\007"
	+ "\000\033\133\061\073\062\110\000\372\000\007\000\033\133\062"
	+ "\073\062\176\000\376\000\007\000\033\133\066\073\062\176\000"
	+ "\000\001\007\000\033\133\065\073\062\176\000\053\000\006\000"
	+ "\033\135\060\073\007\000\152\000\002\000\007\000\170\001\005"
	+ "\000\033\135\060\073\000\000\000\101\000\053\053\054\054\055"
	+ "\055\056\056\060\060\140\140\141\141\146\146\147\147\150\150"
	+ "\151\151\152\152\153\153\154\154\155\155\156\156\157\157\160"
	+ "\160\161\161\162\162\163\163\164\164\165\165\166\166\167\167"
	+ "\170\170\171\171\172\172\173\173\174\174\175\175\176\176\000"
	+ "\003\000\002\000\007\000\063\000\005\000\033\133\065\155\000"
	+ "\064\000\005\000\033\133\061\155\000\002\000\004\000\033\133"
	+ "\132\000\035\000\007\000\033\133\077\062\065\154\000\021\000"
	+ "\007\000\033\133\110\033\133\112\000\040\000\014\000\033\133"
	+ "\063\064\150\033\133\077\062\065\150\000\007\000\002\000\015"
	+ "\000\014\000\021\000\033\133\045\151\045\160\061\045\144\073"
	+ "\045\160\062\045\144\162\000\063\001\011\000\033\133\045\160"
	+ "\061\045\144\104\000\036\000\002\000\010\000\056\001\011\000"
	+ "\033\133\045\160\061\045\144\102\000\033\000\002\000\012\000"
	+ "\065\001\011\000\033\133\045\160\061\045\144\103\000\041\000"
	+ "\004\000\033\133\103\000\032\000\021\000\033\133\045\151\045"
	+ "\160\061\045\144\073\045\160\062\045\144\110\000\070\001\011"
	+ "\000\033\133\045\160\061\045\144\101\000\043\000\003\000\033"
	+ "\115\000\044\000\006\000\033\133\063\064\154\000\054\001\011"
	+ "\000\033\133\045\160\061\045\144\120\000\047\000\004\000\033"
	+ "\133\120\000\067\000\005\000\033\133\062\155\000\055\001\011"
	+ "\000\033\133\045\160\061\045\144\115\000\050\000\004\000\033"
	+ "\133\115\000\024\000\004\000\033\133\112\000\023\000\004\000"
	+ "\033\133\113\000\022\000\005\000\033\133\061\113\000\057\000"
	+ "\007\000\033\050\102\033\051\060\000\150\000\003\000\033\147"
	+ "\000\034\000\004\000\033\133\110\000\166\001\002\000\011\000"
	+ "\153\001\003\000\033\110\000\060\001\011\000\033\133\045\160"
	+ "\061\045\144\100\000\062\001\011\000\033\133\045\160\061\045"
	+ "\144\114\000\166\000\004\000\033\133\114\000\122\001\002\000"
	+ "\012\000\157\000\004\000\033\051\060\000\173\000\002\000\010"
	+ "\000\175\000\004\000\033\133\132\000\332\000\004\000\033\133"
	+ "\115\000\047\001\003\000\033\105\000\116\001\003\000\033\070"
	+ "\000\105\000\005\000\033\133\067\155\000\123\001\003\000\033"
	+ "\115\000\123\000\002\000\017\000\126\000\011\000\033\133\077"
	+ "\061\060\064\071\154\000\131\000\005\000\033\133\064\154\000"
	+ "\016\001\010\000\033\133\077\061\154\033\076\000\143\000\006"
	+ "\000\033\133\062\064\155\000\113\001\021\000\033\143\033\133"
	+ "\077\061\060\060\060\154\033\133\077\062\065\150\000\120\001"
	+ "\003\000\033\067\000\134\001\124\000\033\133\060\045\077\045"
	+ "\160\066\045\164\073\061\045\073\045\077\045\160\061\045\164"
	+ "\073\063\045\073\045\077\045\160\062\045\164\073\064\045\073"
	+ "\045\077\045\160\063\045\164\073\067\045\073\045\077\045\160"
	+ "\064\045\164\073\065\045\073\045\077\045\160\065\045\164\073"
	+ "\062\045\073\155\045\077\045\160\071\045\164\016\045\145\017"
	+ "\045\073\000\125\000\005\000\033\133\155\017\000\061\000\002"
	+ "\000\016\000\065\000\011\000\033\133\077\061\060\064\071\150"
	+ "\000\073\000\005\000\033\133\064\150\000\017\001\010\000\033"
	+ "\133\077\061\150\033\075\000\116\000\005\000\033\133\064\155"
	+ "\000\017\000\005\000\033\133\063\147\000\052\001\011\000\033"
	+ "\133\063\071\073\064\071\155\000\132\001\012\000\033\133\064"
	+ "\045\160\061\045\144\155\000\133\001\012\000\033\133\063\045"
	+ "\160\061\045\144\155\000\074\004\101\000\004\000\153\104\116"
	+ "\000\163\007\000\033\133\061\073\062\102\000\005\000\153\104"
	+ "\116\063\000\163\007\000\033\133\061\073\063\102\000\005\000"
	+ "\153\104\116\064\000\163\007\000\033\133\061\073\064\102\000"
	+ "\005\000\153\104\116\065\000\163\007\000\033\133\061\073\065"
	+ "\102\000\005\000\153\104\116\066\000\163\007\000\033\133\061"
	+ "\073\066\102\000\005\000\153\104\116\067\000\163\007\000\033"
	+ "\133\061\073\067\102\000\006\000\153\114\106\124\063\000\163"
	+ "\007\000\033\133\061\073\063\104\000\006\000\153\114\106\124"
	+ "\064\000\163\007\000\033\133\061\073\064\104\000\006\000\153"
	+ "\114\106\124\065\000\163\007\000\033\133\061\073\065\104\000"
	+ "\006\000\153\114\106\124\066\000\163\007\000\033\133\061\073"
	+ "\066\104\000\006\000\153\114\106\124\067\000\163\007\000\033"
	+ "\133\061\073\067\104\000\006\000\153\122\111\124\063\000\163"
	+ "\007\000\033\133\061\073\063\103\000\006\000\153\122\111\124"
	+ "\064\000\163\007\000\033\133\061\073\064\103\000\006\000\153"
	+ "\122\111\124\065\000\163\007\000\033\133\061\073\065\103\000"
	+ "\006\000\153\122\111\124\066\000\163\007\000\033\133\061\073"
	+ "\066\103\000\006\000\153\122\111\124\067\000\163\007\000\033"
	+ "\133\061\073\067\103\000\004\000\153\125\120\000\163\007\000"
	+ "\033\133\061\073\062\101\000\005\000\153\125\120\063\000\163"
	+ "\007\000\033\133\061\073\063\101\000\005\000\153\125\120\064"
	+ "\000\163\007\000\033\133\061\073\064\101\000\005\000\153\125"
	+ "\120\065\000\163\007\000\033\133\061\073\065\101\000\005\000"
	+ "\153\125\120\066\000\163\007\000\033\133\061\073\066\101\000"
	+ "\005\000\153\125\120\067\000\163\007\000\033\133\061\073\067"
	+ "\101\000\005\000\153\104\103\063\000\163\007\000\033\133\063"
	+ "\073\063\176\000\005\000\153\104\103\064\000\163\007\000\033"
	+ "\133\063\073\064\176\000\005\000\153\104\103\065\000\163\007"
	+ "\000\033\133\063\073\065\176\000\005\000\153\104\103\066\000"
	+ "\163\007\000\033\133\063\073\066\176\000\005\000\153\104\103"
	+ "\067\000\163\007\000\033\133\063\073\067\176\000\006\000\153"
	+ "\105\116\104\063\000\163\007\000\033\133\061\073\063\106\000"
	+ "\006\000\153\105\116\104\064\000\163\007\000\033\133\061\073"
	+ "\064\106\000\006\000\153\105\116\104\065\000\163\007\000\033"
	+ "\133\061\073\065\106\000\006\000\153\105\116\104\066\000\163"
	+ "\007\000\033\133\061\073\066\106\000\006\000\153\105\116\104"
	+ "\067\000\163\007\000\033\133\061\073\067\106\000\006\000\153"
	+ "\110\117\115\063\000\163\007\000\033\133\061\073\063\110\000"
	+ "\006\000\153\110\117\115\064\000\163\007\000\033\133\061\073"
	+ "\064\110\000\006\000\153\110\117\115\065\000\163\007\000\033"
	+ "\133\061\073\065\110\000\006\000\153\110\117\115\066\000\163"
	+ "\007\000\033\133\061\073\066\110\000\006\000\153\110\117\115"
	+ "\067\000\163\007\000\033\133\061\073\067\110\000\005\000\153"
	+ "\111\103\063\000\163\007\000\033\133\062\073\063\176\000\005"
	+ "\000\153\111\103\064\000\163\007\000\033\133\062\073\064\176"
	+ "\000\005\000\153\111\103\065\000\163\007\000\033\133\062\073"
	+ "\065\176\000\005\000\153\111\103\066\000\163\007\000\033\133"
	+ "\062\073\066\176\000\005\000\153\111\103\067\000\163\007\000"
	+ "\033\133\062\073\067\176\000\006\000\153\116\130\124\063\000"
	+ "\163\007\000\033\133\066\073\063\176\000\006\000\153\116\130"
	+ "\124\064\000\163\007\000\033\133\066\073\064\176\000\006\000"
	+ "\153\116\130\124\065\000\163\007\000\033\133\066\073\065\176"
	+ "\000\006\000\153\116\130\124\066\000\163\007\000\033\133\066"
	+ "\073\066\176\000\006\000\153\116\130\124\067\000\163\007\000"
	+ "\033\133\066\073\067\176\000\006\000\153\120\122\126\063\000"
	+ "\163\007\000\033\133\065\073\063\176\000\006\000\153\120\122"
	+ "\126\064\000\163\007\000\033\133\065\073\064\176\000\006\000"
	+ "\153\120\122\126\065\000\163\007\000\033\133\065\073\065\176"
	+ "\000\006\000\153\120\122\126\066\000\163\007\000\033\133\065"
	+ "\073\066\176\000\006\000\153\120\122\126\067\000\163\007\000"
	+ "\033\133\065\073\067\176\000\003\000\124\123\000\163\005\000"
	+ "\033\135\060\073\000\003\000\103\162\000\163\007\000\033\135"
	+ "\061\061\062\007\000\003\000\103\163\000\163\014\000\033\135"
	+ "\061\062\073\045\160\061\045\163\007\000\003\000\115\163\000"
	+ "\163\022\000\033\135\065\062\073\045\160\061\045\163\073\045"
	+ "\160\062\045\163\007\000\003\000\123\145\000\163\006\000\033"
	+ "\133\062\040\161\000\003\000\123\163\000\163\012\000\033\133"
	+ "\045\160\061\045\144\040\161\000\003\000\142\163\000\146\001"
	+ "\003\000\160\164\000\146\001\003\000\107\060\000\146\001\003"
	+ "\000\125\070\000\156\001\000\003\000\105\060\000\163\004\000"
	+ "\033\050\102\000\003\000\123\060\000\163\010\000\033\050\045"
	+ "\160\061\045\143\000\003\000\101\130\000\146\001",
	+ 2877
	+ },
	+ {
	+ "tmux-256color",
	+ "\001\016\000\164\155\165\170\055\062\065\066\143\157\154\157"
	+ "\162\000\000\000\000\000\024\000\006\000\020\000\001\001\000"
	+ "\001\016\000\001\026\000\001\027\000\001\011\000\001\026\000"
	+ "\005\000\016\000\000\001\021\000\377\177\004\000\120\000\007"
	+ "\000\010\000\012\000\030\000\056\007\231\000\132\001\100\000"
	+ "\033\133\045\077\045\160\061\045\173\070\175\045\074\045\164"
	+ "\064\045\160\061\045\144\045\145\045\160\061\045\173\061\066"
	+ "\175\045\074\045\164\061\060\045\160\061\045\173\070\175\045"
	+ "\055\045\144\045\145\064\070\073\065\073\045\160\061\045\144"
	+ "\045\073\155\000\133\001\077\000\033\133\045\077\045\160\061"
	+ "\045\173\070\175\045\074\045\164\063\045\160\061\045\144\045"
	+ "\145\045\160\061\045\173\061\066\175\045\074\045\164\071\045"
	+ "\160\061\045\173\070\175\045\055\045\144\045\145\063\070\073"
	+ "\065\073\045\160\061\045\144\045\073\155\000\132\000\006\000"
	+ "\033\133\062\063\155\000\140\000\006\000\033\133\062\067\155"
	+ "\000\074\000\005\000\033\133\063\155\000\112\000\005\000\033"
	+ "\133\067\155\000\210\000\005\000\033\133\063\176\000\324\000"
	+ "\005\000\033\133\062\176\000\335\000\005\000\033\133\066\176"
	+ "\000\340\000\005\000\033\133\065\176\000\214\000\005\000\033"
	+ "\133\064\176\000\323\000\005\000\033\133\061\176\000\326\000"
	+ "\004\000\033\117\104\000\212\000\004\000\033\117\102\000\351"
	+ "\000\004\000\033\117\103\000\015\001\004\000\033\117\101\000"
	+ "\222\000\004\000\033\117\120\000\233\000\006\000\033\133\062"
	+ "\061\176\000\234\000\006\000\033\133\062\063\176\000\235\000"
	+ "\006\000\033\133\062\064\176\000\236\000\007\000\033\133\061"
	+ "\073\062\120\000\237\000\007\000\033\133\061\073\062\121\000"
	+ "\240\000\007\000\033\133\061\073\062\122\000\241\000\007\000"
	+ "\033\133\061\073\062\123\000\242\000\010\000\033\133\061\065"
	+ "\073\062\176\000\243\000\010\000\033\133\061\067\073\062\176"
	+ "\000\244\000\010\000\033\133\061\070\073\062\176\000\223\000"
	+ "\004\000\033\117\121\000\245\000\010\000\033\133\061\071\073"
	+ "\062\176\000\246\000\010\000\033\133\062\060\073\062\176\000"
	+ "\247\000\010\000\033\133\062\061\073\062\176\000\250\000\010"
	+ "\000\033\133\062\063\073\062\176\000\251\000\010\000\033\133"
	+ "\062\064\073\062\176\000\252\000\007\000\033\133\061\073\065"
	+ "\120\000\253\000\007\000\033\133\061\073\065\121\000\254\000"
	+ "\007\000\033\133\061\073\065\122\000\255\000\007\000\033\133"
	+ "\061\073\065\123\000\256\000\010\000\033\133\061\065\073\065"
	+ "\176\000\224\000\004\000\033\117\122\000\257\000\010\000\033"
	+ "\133\061\067\073\065\176\000\260\000\010\000\033\133\061\070"
	+ "\073\065\176\000\261\000\010\000\033\133\061\071\073\065\176"
	+ "\000\262\000\010\000\033\133\062\060\073\065\176\000\263\000"
	+ "\010\000\033\133\062\061\073\065\176\000\264\000\010\000\033"
	+ "\133\062\063\073\065\176\000\265\000\010\000\033\133\062\064"
	+ "\073\065\176\000\266\000\007\000\033\133\061\073\066\120\000"
	+ "\267\000\007\000\033\133\061\073\066\121\000\270\000\007\000"
	+ "\033\133\061\073\066\122\000\225\000\004\000\033\117\123\000"
	+ "\271\000\007\000\033\133\061\073\066\123\000\272\000\010\000"
	+ "\033\133\061\065\073\066\176\000\273\000\010\000\033\133\061"
	+ "\067\073\066\176\000\274\000\010\000\033\133\061\070\073\066"
	+ "\176\000\275\000\010\000\033\133\061\071\073\066\176\000\276"
	+ "\000\010\000\033\133\062\060\073\066\176\000\277\000\010\000"
	+ "\033\133\062\061\073\066\176\000\300\000\010\000\033\133\062"
	+ "\063\073\066\176\000\301\000\010\000\033\133\062\064\073\066"
	+ "\176\000\302\000\007\000\033\133\061\073\063\120\000\226\000"
	+ "\006\000\033\133\061\065\176\000\303\000\007\000\033\133\061"
	+ "\073\063\121\000\304\000\007\000\033\133\061\073\063\122\000"
	+ "\305\000\007\000\033\133\061\073\063\123\000\306\000\010\000"
	+ "\033\133\061\065\073\063\176\000\307\000\010\000\033\133\061"
	+ "\067\073\063\176\000\310\000\010\000\033\133\061\070\073\063"
	+ "\176\000\311\000\010\000\033\133\061\071\073\063\176\000\312"
	+ "\000\010\000\033\133\062\060\073\063\176\000\313\000\010\000"
	+ "\033\133\062\061\073\063\176\000\314\000\010\000\033\133\062"
	+ "\063\073\063\176\000\227\000\006\000\033\133\061\067\176\000"
	+ "\315\000\010\000\033\133\062\064\073\063\176\000\316\000\007"
	+ "\000\033\133\061\073\064\120\000\317\000\007\000\033\133\061"
	+ "\073\064\121\000\320\000\007\000\033\133\061\073\064\122\000"
	+ "\230\000\006\000\033\133\061\070\176\000\231\000\006\000\033"
	+ "\133\061\071\176\000\232\000\006\000\033\133\062\060\176\000"
	+ "\373\000\007\000\033\133\061\073\062\104\000\005\001\007\000"
	+ "\033\133\061\073\062\103\000\366\000\007\000\033\133\061\073"
	+ "\062\102\000\002\001\007\000\033\133\061\073\062\101\000\360"
	+ "\000\007\000\033\133\063\073\062\176\000\363\000\007\000\033"
	+ "\133\061\073\062\106\000\371\000\007\000\033\133\061\073\062"
	+ "\110\000\372\000\007\000\033\133\062\073\062\176\000\376\000"
	+ "\007\000\033\133\066\073\062\176\000\000\001\007\000\033\133"
	+ "\065\073\062\176\000\053\000\006\000\033\135\060\073\007\000"
	+ "\152\000\002\000\007\000\170\001\005\000\033\135\060\073\000"
	+ "\000\000\101\000\053\053\054\054\055\055\056\056\060\060\140"
	+ "\140\141\141\146\146\147\147\150\150\151\151\152\152\153\153"
	+ "\154\154\155\155\156\156\157\157\160\160\161\161\162\162\163"
	+ "\163\164\164\165\165\166\166\167\167\170\170\171\171\172\172"
	+ "\173\173\174\174\175\175\176\176\000\003\000\002\000\007\000"
	+ "\063\000\005\000\033\133\065\155\000\064\000\005\000\033\133"
	+ "\061\155\000\002\000\004\000\033\133\132\000\035\000\007\000"
	+ "\033\133\077\062\065\154\000\021\000\007\000\033\133\110\033"
	+ "\133\112\000\040\000\014\000\033\133\063\064\150\033\133\077"
	+ "\062\065\150\000\007\000\002\000\015\000\014\000\021\000\033"
	+ "\133\045\151\045\160\061\045\144\073\045\160\062\045\144\162"
	+ "\000\063\001\011\000\033\133\045\160\061\045\144\104\000\036"
	+ "\000\002\000\010\000\056\001\011\000\033\133\045\160\061\045"
	+ "\144\102\000\033\000\002\000\012\000\065\001\011\000\033\133"
	+ "\045\160\061\045\144\103\000\041\000\004\000\033\133\103\000"
	+ "\032\000\021\000\033\133\045\151\045\160\061\045\144\073\045"
	+ "\160\062\045\144\110\000\070\001\011\000\033\133\045\160\061"
	+ "\045\144\101\000\043\000\003\000\033\115\000\044\000\006\000"
	+ "\033\133\063\064\154\000\054\001\011\000\033\133\045\160\061"
	+ "\045\144\120\000\047\000\004\000\033\133\120\000\067\000\005"
	+ "\000\033\133\062\155\000\055\001\011\000\033\133\045\160\061"
	+ "\045\144\115\000\050\000\004\000\033\133\115\000\024\000\004"
	+ "\000\033\133\112\000\023\000\004\000\033\133\113\000\022\000"
	+ "\005\000\033\133\061\113\000\057\000\007\000\033\050\102\033"
	+ "\051\060\000\150\000\003\000\033\147\000\034\000\004\000\033"
	+ "\133\110\000\166\001\002\000\011\000\153\001\003\000\033\110"
	+ "\000\060\001\011\000\033\133\045\160\061\045\144\100\000\062"
	+ "\001\011\000\033\133\045\160\061\045\144\114\000\166\000\004"
	+ "\000\033\133\114\000\122\001\002\000\012\000\157\000\004\000"
	+ "\033\051\060\000\173\000\002\000\010\000\175\000\004\000\033"
	+ "\133\132\000\332\000\004\000\033\133\115\000\047\001\003\000"
	+ "\033\105\000\116\001\003\000\033\070\000\105\000\005\000\033"
	+ "\133\067\155\000\123\001\003\000\033\115\000\123\000\002\000"
	+ "\017\000\126\000\011\000\033\133\077\061\060\064\071\154\000"
	+ "\131\000\005\000\033\133\064\154\000\016\001\010\000\033\133"
	+ "\077\061\154\033\076\000\143\000\006\000\033\133\062\064\155"
	+ "\000\113\001\021\000\033\143\033\133\077\061\060\060\060\154"
	+ "\033\133\077\062\065\150\000\120\001\003\000\033\067\000\134"
	+ "\001\124\000\033\133\060\045\077\045\160\066\045\164\073\061"
	+ "\045\073\045\077\045\160\061\045\164\073\063\045\073\045\077"
	+ "\045\160\062\045\164\073\064\045\073\045\077\045\160\063\045"
	+ "\164\073\067\045\073\045\077\045\160\064\045\164\073\065\045"
	+ "\073\045\077\045\160\065\045\164\073\062\045\073\155\045\077"
	+ "\045\160\071\045\164\016\045\145\017\045\073\000\125\000\005"
	+ "\000\033\133\155\017\000\061\000\002\000\016\000\065\000\011"
	+ "\000\033\133\077\061\060\064\071\150\000\073\000\005\000\033"
	+ "\133\064\150\000\017\001\010\000\033\133\077\061\150\033\075"
	+ "\000\116\000\005\000\033\133\064\155\000\017\000\005\000\033"
	+ "\133\063\147\000\052\001\011\000\033\133\063\071\073\064\071"
	+ "\155\000\074\004\101\000\004\000\153\104\116\000\163\007\000"
	+ "\033\133\061\073\062\102\000\005\000\153\104\116\063\000\163"
	+ "\007\000\033\133\061\073\063\102\000\005\000\153\104\116\064"
	+ "\000\163\007\000\033\133\061\073\064\102\000\005\000\153\104"
	+ "\116\065\000\163\007\000\033\133\061\073\065\102\000\005\000"
	+ "\153\104\116\066\000\163\007\000\033\133\061\073\066\102\000"
	+ "\005\000\153\104\116\067\000\163\007\000\033\133\061\073\067"
	+ "\102\000\006\000\153\114\106\124\063\000\163\007\000\033\133"
	+ "\061\073\063\104\000\006\000\153\114\106\124\064\000\163\007"
	+ "\000\033\133\061\073\064\104\000\006\000\153\114\106\124\065"
	+ "\000\163\007\000\033\133\061\073\065\104\000\006\000\153\114"
	+ "\106\124\066\000\163\007\000\033\133\061\073\066\104\000\006"
	+ "\000\153\114\106\124\067\000\163\007\000\033\133\061\073\067"
	+ "\104\000\006\000\153\122\111\124\063\000\163\007\000\033\133"
	+ "\061\073\063\103\000\006\000\153\122\111\124\064\000\163\007"
	+ "\000\033\133\061\073\064\103\000\006\000\153\122\111\124\065"
	+ "\000\163\007\000\033\133\061\073\065\103\000\006\000\153\122"
	+ "\111\124\066\000\163\007\000\033\133\061\073\066\103\000\006"
	+ "\000\153\122\111\124\067\000\163\007\000\033\133\061\073\067"
	+ "\103\000\004\000\153\125\120\000\163\007\000\033\133\061\073"
	+ "\062\101\000\005\000\153\125\120\063\000\163\007\000\033\133"
	+ "\061\073\063\101\000\005\000\153\125\120\064\000\163\007\000"
	+ "\033\133\061\073\064\101\000\005\000\153\125\120\065\000\163"
	+ "\007\000\033\133\061\073\065\101\000\005\000\153\125\120\066"
	+ "\000\163\007\000\033\133\061\073\066\101\000\005\000\153\125"
	+ "\120\067\000\163\007\000\033\133\061\073\067\101\000\005\000"
	+ "\153\104\103\063\000\163\007\000\033\133\063\073\063\176\000"
	+ "\005\000\153\104\103\064\000\163\007\000\033\133\063\073\064"
	+ "\176\000\005\000\153\104\103\065\000\163\007\000\033\133\063"
	+ "\073\065\176\000\005\000\153\104\103\066\000\163\007\000\033"
	+ "\133\063\073\066\176\000\005\000\153\104\103\067\000\163\007"
	+ "\000\033\133\063\073\067\176\000\006\000\153\105\116\104\063"
	+ "\000\163\007\000\033\133\061\073\063\106\000\006\000\153\105"
	+ "\116\104\064\000\163\007\000\033\133\061\073\064\106\000\006"
	+ "\000\153\105\116\104\065\000\163\007\000\033\133\061\073\065"
	+ "\106\000\006\000\153\105\116\104\066\000\163\007\000\033\133"
	+ "\061\073\066\106\000\006\000\153\105\116\104\067\000\163\007"
	+ "\000\033\133\061\073\067\106\000\006\000\153\110\117\115\063"
	+ "\000\163\007\000\033\133\061\073\063\110\000\006\000\153\110"
	+ "\117\115\064\000\163\007\000\033\133\061\073\064\110\000\006"
	+ "\000\153\110\117\115\065\000\163\007\000\033\133\061\073\065"
	+ "\110\000\006\000\153\110\117\115\066\000\163\007\000\033\133"
	+ "\061\073\066\110\000\006\000\153\110\117\115\067\000\163\007"
	+ "\000\033\133\061\073\067\110\000\005\000\153\111\103\063\000"
	+ "\163\007\000\033\133\062\073\063\176\000\005\000\153\111\103"
	+ "\064\000\163\007\000\033\133\062\073\064\176\000\005\000\153"
	+ "\111\103\065\000\163\007\000\033\133\062\073\065\176\000\005"
	+ "\000\153\111\103\066\000\163\007\000\033\133\062\073\066\176"
	+ "\000\005\000\153\111\103\067\000\163\007\000\033\133\062\073"
	+ "\067\176\000\006\000\153\116\130\124\063\000\163\007\000\033"
	+ "\133\066\073\063\176\000\006\000\153\116\130\124\064\000\163"
	+ "\007\000\033\133\066\073\064\176\000\006\000\153\116\130\124"
	+ "\065\000\163\007\000\033\133\066\073\065\176\000\006\000\153"
	+ "\116\130\124\066\000\163\007\000\033\133\066\073\066\176\000"
	+ "\006\000\153\116\130\124\067\000\163\007\000\033\133\066\073"
	+ "\067\176\000\006\000\153\120\122\126\063\000\163\007\000\033"
	+ "\133\065\073\063\176\000\006\000\153\120\122\126\064\000\163"
	+ "\007\000\033\133\065\073\064\176\000\006\000\153\120\122\126"
	+ "\065\000\163\007\000\033\133\065\073\065\176\000\006\000\153"
	+ "\120\122\126\066\000\163\007\000\033\133\065\073\066\176\000"
	+ "\006\000\153\120\122\126\067\000\163\007\000\033\133\065\073"
	+ "\067\176\000\003\000\124\123\000\163\005\000\033\135\060\073"
	+ "\000\003\000\103\162\000\163\007\000\033\135\061\061\062\007"
	+ "\000\003\000\103\163\000\163\014\000\033\135\061\062\073\045"
	+ "\160\061\045\163\007\000\003\000\115\163\000\163\022\000\033"
	+ "\135\065\062\073\045\160\061\045\163\073\045\160\062\045\163"
	+ "\007\000\003\000\123\145\000\163\006\000\033\133\062\040\161"
	+ "\000\003\000\123\163\000\163\012\000\033\133\045\160\061\045"
	+ "\144\040\161\000\003\000\142\163\000\146\001\003\000\160\164"
	+ "\000\146\001\003\000\107\060\000\146\001\003\000\125\070\000"
	+ "\156\001\000\003\000\105\060\000\163\004\000\033\050\102\000"
	+ "\003\000\123\060\000\163\010\000\033\050\045\160\061\045\143"
	+ "\000\003\000\101\130\000\146\001",
	+ 2993
	+ },
	+ {
	+ "vt100",
	+ "\001\006\000\166\164\061\060\060\000\000\000\000\000\021\000"
	+ "\005\000\001\000\001\036\000\001\027\000\001\011\000\001\044"
	+ "\000\001\022\000\004\000\004\000\120\000\007\000\010\000\012"
	+ "\000\030\000\036\000\003\000\100\003\107\000\000\000\063\000"
	+ "\140\140\141\141\146\146\147\147\152\152\153\153\154\154\155"
	+ "\155\156\156\157\157\160\160\161\161\162\162\163\163\164\164"
	+ "\165\165\166\166\167\167\170\170\171\171\172\172\173\173\174"
	+ "\174\175\175\176\176\000\003\000\002\000\007\000\063\000\011"
	+ "\000\033\133\065\155\044\074\062\076\000\064\000\011\000\033"
	+ "\133\061\155\044\074\062\076\000\021\000\014\000\033\133\110"
	+ "\033\133\112\044\074\065\060\076\000\007\000\002\000\015\000"
	+ "\014\000\021\000\033\133\045\151\045\160\061\045\144\073\045"
	+ "\160\062\045\144\162\000\063\001\011\000\033\133\045\160\061"
	+ "\045\144\104\000\036\000\002\000\010\000\056\001\011\000\033"
	+ "\133\045\160\061\045\144\102\000\033\000\002\000\012\000\065"
	+ "\001\011\000\033\133\045\160\061\045\144\103\000\041\000\010"
	+ "\000\033\133\103\044\074\062\076\000\032\000\025\000\033\133"
	+ "\045\151\045\160\061\045\144\073\045\160\062\045\144\110\044"
	+ "\074\065\076\000\070\001\011\000\033\133\045\160\061\045\144"
	+ "\101\000\043\000\010\000\033\133\101\044\074\062\076\000\024"
	+ "\000\011\000\033\133\112\044\074\065\060\076\000\023\000\010"
	+ "\000\033\133\113\044\074\063\076\000\022\000\011\000\033\133"
	+ "\061\113\044\074\063\076\000\057\000\007\000\033\050\102\033"
	+ "\051\060\000\034\000\004\000\033\133\110\000\166\001\002\000"
	+ "\011\000\153\001\003\000\033\110\000\122\001\002\000\012\000"
	+ "\173\000\002\000\010\000\326\000\004\000\033\117\104\000\212"
	+ "\000\004\000\033\117\102\000\351\000\004\000\033\117\103\000"
	+ "\015\001\004\000\033\117\101\000\021\001\004\000\160\146\061"
	+ "\000\022\001\004\000\160\146\062\000\023\001\004\000\160\146"
	+ "\063\000\024\001\004\000\160\146\064\000\100\001\005\000\033"
	+ "\133\060\151\000\102\001\005\000\033\133\064\151\000\103\001"
	+ "\005\000\033\133\065\151\000\116\001\003\000\033\070\000\105"
	+ "\000\011\000\033\133\067\155\044\074\062\076\000\123\001\007"
	+ "\000\033\115\044\074\065\076\000\123\000\002\000\017\000\124"
	+ "\000\006\000\033\133\077\067\154\000\016\001\010\000\033\133"
	+ "\077\061\154\033\076\000\140\000\010\000\033\133\155\044\074"
	+ "\062\076\000\143\000\010\000\033\133\155\044\074\062\076\000"
	+ "\113\001\034\000\033\076\033\133\077\063\154\033\133\077\064"
	+ "\154\033\133\077\065\154\033\133\077\067\150\033\133\077\070"
	+ "\150\000\120\001\003\000\033\067\000\134\001\114\000\033\133"
	+ "\060\045\077\045\160\061\045\160\066\045\174\045\164\073\061"
	+ "\045\073\045\077\045\160\062\045\164\073\064\045\073\045\077"
	+ "\045\160\061\045\160\063\045\174\045\164\073\067\045\073\045"
	+ "\077\045\160\064\045\164\073\065\045\073\155\045\077\045\160"
	+ "\071\045\164\016\045\145\017\045\073\044\074\062\076\000\125"
	+ "\000\011\000\033\133\155\017\044\074\062\076\000\061\000\002"
	+ "\000\016\000\062\000\006\000\033\133\077\067\150\000\017\001"
	+ "\010\000\033\133\077\061\150\033\075\000\112\000\011\000\033"
	+ "\133\067\155\044\074\062\076\000\116\000\011\000\033\133\064"
	+ "\155\044\074\062\076\000\017\000\005\000\033\133\063\147\000"
	+ "\221\000\004\000\033\117\171\000\233\000\004\000\033\117\170"
	+ "\000\226\000\004\000\033\117\164\000\227\000\004\000\033\117"
	+ "\165\000\230\000\004\000\033\117\166\000\231\000\004\000\033"
	+ "\117\154\000\232\000\004\000\033\117\167\000\215\000\004\000"
	+ "\033\117\115\000\222\000\004\000\033\117\120\000\223\000\004"
	+ "\000\033\117\121\000\224\000\004\000\033\117\122\000\225\000"
	+ "\004\000\033\117\123\000\170\000\004\000\033\117\161\000\171"
	+ "\000\004\000\033\117\163\000\172\000\004\000\033\117\162\000"
	+ "\176\000\004\000\033\117\160\000\177\000\004\000\033\117\156"
	+ "\000\011\000\001\000\003\000\142\163\000\146\001",
	+ 897
	+ },
	+ {
	+ "vt220",
	+ "\001\006\000\166\164\062\062\060\000\000\000\000\000\024\000"
	+ "\006\000\001\000\001\026\000\001\027\000\001\011\000\001\044"
	+ "\000\001\036\000\001\022\000\004\000\004\000\120\000\007\000"
	+ "\010\000\012\000\030\000\036\000\003\000\067\004\137\000\000"
	+ "\000\063\000\140\140\141\141\146\146\147\147\152\152\153\153"
	+ "\154\154\155\155\156\156\157\157\160\160\161\161\162\162\163"
	+ "\163\164\164\165\165\166\166\167\167\170\170\171\171\172\172"
	+ "\173\173\174\174\175\175\176\176\000\003\000\002\000\007\000"
	+ "\063\000\005\000\033\133\065\155\000\064\000\005\000\033\133"
	+ "\061\155\000\021\000\007\000\033\133\110\033\133\112\000\007"
	+ "\000\002\000\015\000\014\000\021\000\033\133\045\151\045\160"
	+ "\061\045\144\073\045\160\062\045\144\162\000\063\001\011\000"
	+ "\033\133\045\160\061\045\144\104\000\036\000\002\000\010\000"
	+ "\056\001\011\000\033\133\045\160\061\045\144\102\000\033\000"
	+ "\002\000\012\000\065\001\011\000\033\133\045\160\061\045\144"
	+ "\103\000\041\000\004\000\033\133\103\000\032\000\021\000\033"
	+ "\133\045\151\045\160\061\045\144\073\045\160\062\045\144\110"
	+ "\000\070\001\011\000\033\133\045\160\061\045\144\101\000\043"
	+ "\000\004\000\033\133\101\000\054\001\011\000\033\133\045\160"
	+ "\061\045\144\120\000\047\000\004\000\033\133\120\000\055\001"
	+ "\011\000\033\133\045\160\061\045\144\115\000\050\000\004\000"
	+ "\033\133\115\000\122\000\011\000\033\133\045\160\061\045\144"
	+ "\130\000\024\000\004\000\033\133\112\000\023\000\004\000\033"
	+ "\133\113\000\022\000\005\000\033\133\061\113\000\057\000\004"
	+ "\000\033\051\060\000\150\000\022\000\033\133\077\065\150\044"
	+ "\074\062\060\060\057\076\033\133\077\065\154\000\034\000\004"
	+ "\000\033\133\110\000\166\001\002\000\011\000\153\001\003\000"
	+ "\033\110\000\060\001\011\000\033\133\045\160\061\045\144\100"
	+ "\000\161\000\030\000\057\165\163\162\057\163\150\141\162\145"
	+ "\057\164\141\142\163\145\164\057\166\164\061\060\060\000\062"
	+ "\001\011\000\033\133\045\160\061\045\144\114\000\166\000\004"
	+ "\000\033\133\114\000\122\001\003\000\033\104\000\157\000\026"
	+ "\000\033\133\077\067\150\033\133\076\033\133\077\061\154\033"
	+ "\040\106\033\133\077\064\154\000\173\000\002\000\010\000\326"
	+ "\000\004\000\033\133\104\000\212\000\004\000\033\133\102\000"
	+ "\351\000\004\000\033\133\103\000\015\001\004\000\033\133\101"
	+ "\000\210\000\005\000\033\133\063\176\000\222\000\004\000\033"
	+ "\117\120\000\233\000\006\000\033\133\062\061\176\000\234\000"
	+ "\006\000\033\133\062\063\176\000\235\000\006\000\033\133\062"
	+ "\064\176\000\236\000\006\000\033\133\062\065\176\000\237\000"
	+ "\006\000\033\133\062\066\176\000\242\000\006\000\033\133\063"
	+ "\061\176\000\243\000\006\000\033\133\063\062\176\000\244\000"
	+ "\006\000\033\133\063\063\176\000\223\000\004\000\033\117\121"
	+ "\000\245\000\006\000\033\133\063\064\176\000\224\000\004\000"
	+ "\033\117\122\000\225\000\004\000\033\117\123\000\227\000\006"
	+ "\000\033\133\061\067\176\000\230\000\006\000\033\133\061\070"
	+ "\176\000\231\000\006\000\033\133\061\071\176\000\232\000\006"
	+ "\000\033\133\062\060\176\000\321\000\005\000\033\133\061\176"
	+ "\000\322\000\006\000\033\133\062\070\176\000\324\000\005\000"
	+ "\033\133\062\176\000\335\000\005\000\033\133\066\176\000\340"
	+ "\000\005\000\033\133\065\176\000\343\000\006\000\033\133\062"
	+ "\071\176\000\362\000\005\000\033\133\064\176\000\021\001\004"
	+ "\000\160\146\061\000\022\001\004\000\160\146\062\000\023\001"
	+ "\004\000\160\146\063\000\024\001\004\000\160\146\064\000\047"
	+ "\001\003\000\033\105\000\116\001\003\000\033\070\000\105\000"
	+ "\005\000\033\133\067\155\000\123\001\003\000\033\115\000\123"
	+ "\000\010\000\033\050\102\044\074\064\076\000\124\000\006\000"
	+ "\033\133\077\067\154\000\131\000\005\000\033\133\064\154\000"
	+ "\140\000\006\000\033\133\062\067\155\000\143\000\006\000\033"
	+ "\133\062\064\155\000\112\001\006\000\033\133\077\063\154\000"
	+ "\120\001\003\000\033\067\000\134\001\113\000\033\133\060\045"
	+ "\077\045\160\066\045\164\073\061\045\073\045\077\045\160\062"
	+ "\045\164\073\064\045\073\045\077\045\160\064\045\164\073\065"
	+ "\045\073\045\077\045\160\061\045\160\063\045\174\045\164\073"
	+ "\067\045\073\155\045\077\045\160\071\045\164\033\050\060\045"
	+ "\145\033\050\102\045\073\044\074\062\076\000\125\000\007\000"
	+ "\033\133\155\033\050\102\000\061\000\010\000\033\050\060\044"
	+ "\074\062\076\000\062\000\006\000\033\133\077\067\150\000\073"
	+ "\000\005\000\033\133\064\150\000\112\000\005\000\033\133\067"
	+ "\155\000\116\000\005\000\033\133\064\155\000\017\000\005\000"
	+ "\033\133\063\147\000\100\001\004\000\033\133\151\000\102\001"
	+ "\005\000\033\133\064\151\000\103\001\005\000\033\133\065\151"
	+ "\000\200\001\013\000\033\133\045\151\045\144\073\045\144\122"
	+ "\000\201\001\005\000\033\133\066\156\000\202\001\023\000\033"
	+ "\133\077\045\133\073\060\061\062\063\064\065\066\067\070\071"
	+ "\135\143\000\203\001\004\000\033\133\143\000\011\000\001\000"
	+ "\003\000\142\163\000\146\001",
	+ 1147
	+ },
	+ {
	+ "wsvt25",
	+ "\001\007\000\167\163\166\164\062\065\000\000\000\000\000\027"
	+ "\000\007\000\002\000\001\027\000\001\001\000\001\026\000\001"
	+ "\011\000\001\044\000\001\036\000\001\032\000\006\000\016\000"
	+ "\010\000\004\000\120\000\007\000\010\000\012\000\031\000\021"
	+ "\000\100\000\036\000\003\000\207\004\147\000\035\000\007\000"
	+ "\033\133\077\062\065\154\000\040\000\007\000\033\133\077\062"
	+ "\065\150\000\157\000\013\000\033\133\162\033\133\062\065\073"
	+ "\061\110\000\210\000\005\000\033\133\063\176\000\214\000\005"
	+ "\000\033\133\070\176\000\222\000\006\000\033\133\061\061\176"
	+ "\000\233\000\006\000\033\133\062\061\176\000\234\000\006\000"
	+ "\033\133\062\063\176\000\235\000\006\000\033\133\062\064\176"
	+ "\000\223\000\006\000\033\133\061\062\176\000\224\000\006\000"
	+ "\033\133\061\063\176\000\225\000\006\000\033\133\061\064\176"
	+ "\000\226\000\006\000\033\133\061\065\176\000\227\000\006\000"
	+ "\033\133\061\067\176\000\230\000\006\000\033\133\061\070\176"
	+ "\000\231\000\006\000\033\133\061\071\176\000\232\000\006\000"
	+ "\033\133\062\060\176\000\323\000\005\000\033\133\067\176\000"
	+ "\052\001\004\000\033\133\155\000\112\001\003\000\033\143\000"
	+ "\132\001\012\000\033\133\064\045\160\061\045\144\155\000\133"
	+ "\001\012\000\033\133\063\045\160\061\045\144\155\000\000\000"
	+ "\063\000\140\140\141\141\146\146\147\147\152\152\153\153\154"
	+ "\154\155\155\156\156\157\157\160\160\161\161\162\162\163\163"
	+ "\164\164\165\165\166\166\167\167\170\170\171\171\172\172\173"
	+ "\173\174\174\175\175\176\176\000\003\000\002\000\007\000\063"
	+ "\000\005\000\033\133\065\155\000\064\000\005\000\033\133\061"
	+ "\155\000\021\000\007\000\033\133\110\033\133\112\000\007\000"
	+ "\002\000\015\000\014\000\021\000\033\133\045\151\045\160\061"
	+ "\045\144\073\045\160\062\045\144\162\000\063\001\011\000\033"
	+ "\133\045\160\061\045\144\104\000\036\000\002\000\010\000\056"
	+ "\001\011\000\033\133\045\160\061\045\144\102\000\033\000\002"
	+ "\000\012\000\065\001\011\000\033\133\045\160\061\045\144\103"
	+ "\000\041\000\004\000\033\133\103\000\032\000\021\000\033\133"
	+ "\045\151\045\160\061\045\144\073\045\160\062\045\144\110\000"
	+ "\070\001\011\000\033\133\045\160\061\045\144\101\000\043\000"
	+ "\004\000\033\133\101\000\054\001\011\000\033\133\045\160\061"
	+ "\045\144\120\000\047\000\004\000\033\133\120\000\055\001\011"
	+ "\000\033\133\045\160\061\045\144\115\000\050\000\004\000\033"
	+ "\133\115\000\122\000\011\000\033\133\045\160\061\045\144\130"
	+ "\000\024\000\004\000\033\133\112\000\023\000\004\000\033\133"
	+ "\113\000\022\000\005\000\033\133\061\113\000\057\000\004\000"
	+ "\033\051\060\000\150\000\022\000\033\133\077\065\150\044\074"
	+ "\062\060\060\057\076\033\133\077\065\154\000\034\000\004\000"
	+ "\033\133\110\000\166\001\002\000\011\000\153\001\003\000\033"
	+ "\110\000\060\001\011\000\033\133\045\160\061\045\144\100\000"
	+ "\161\000\030\000\057\165\163\162\057\163\150\141\162\145\057"
	+ "\164\141\142\163\145\164\057\166\164\061\060\060\000\062\001"
	+ "\011\000\033\133\045\160\061\045\144\114\000\166\000\004\000"
	+ "\033\133\114\000\122\001\003\000\033\104\000\173\000\002\000"
	+ "\010\000\326\000\004\000\033\133\104\000\212\000\004\000\033"
	+ "\133\102\000\351\000\004\000\033\133\103\000\015\001\004\000"
	+ "\033\133\101\000\236\000\006\000\033\133\062\065\176\000\237"
	+ "\000\006\000\033\133\062\066\176\000\242\000\006\000\033\133"
	+ "\063\061\176\000\243\000\006\000\033\133\063\062\176\000\244"
	+ "\000\006\000\033\133\063\063\176\000\245\000\006\000\033\133"
	+ "\063\064\176\000\321\000\005\000\033\133\061\176\000\322\000"
	+ "\006\000\033\133\062\070\176\000\324\000\005\000\033\133\062"
	+ "\176\000\335\000\005\000\033\133\066\176\000\340\000\005\000"
	+ "\033\133\065\176\000\343\000\006\000\033\133\062\071\176\000"
	+ "\362\000\005\000\033\133\064\176\000\021\001\004\000\160\146"
	+ "\061\000\022\001\004\000\160\146\062\000\023\001\004\000\160"
	+ "\146\063\000\024\001\004\000\160\146\064\000\047\001\003\000"
	+ "\033\105\000\116\001\003\000\033\070\000\105\000\005\000\033"
	+ "\133\067\155\000\123\001\003\000\033\115\000\123\000\010\000"
	+ "\033\050\102\044\074\064\076\000\124\000\006\000\033\133\077"
	+ "\067\154\000\131\000\005\000\033\133\064\154\000\140\000\006"
	+ "\000\033\133\062\067\155\000\143\000\006\000\033\133\062\064"
	+ "\155\000\120\001\003\000\033\067\000\134\001\113\000\033\133"
	+ "\060\045\077\045\160\066\045\164\073\061\045\073\045\077\045"
	+ "\160\062\045\164\073\064\045\073\045\077\045\160\064\045\164"
	+ "\073\065\045\073\045\077\045\160\061\045\160\063\045\174\045"
	+ "\164\073\067\045\073\155\045\077\045\160\071\045\164\033\050"
	+ "\060\045\145\033\050\102\045\073\044\074\062\076\000\125\000"
	+ "\007\000\033\133\155\033\050\102\000\061\000\010\000\033\050"
	+ "\060\044\074\062\076\000\062\000\006\000\033\133\077\067\150"
	+ "\000\073\000\005\000\033\133\064\150\000\112\000\005\000\033"
	+ "\133\067\155\000\116\000\005\000\033\133\064\155\000\017\000"
	+ "\005\000\033\133\063\147\000\100\001\004\000\033\133\151\000"
	+ "\102\001\005\000\033\133\064\151\000\103\001\005\000\033\133"
	+ "\065\151\000\200\001\013\000\033\133\045\151\045\144\073\045"
	+ "\144\122\000\201\001\005\000\033\133\066\156\000\202\001\023"
	+ "\000\033\133\077\045\133\073\060\061\062\063\064\065\066\067"
	+ "\070\071\135\143\000\203\001\004\000\033\133\143\000\011\000"
	+ "\001\000\003\000\142\163\000\146\001",
	+ 1239
	+ },
	+ {
	+ "xterm",
	+ "\001\006\000\170\164\145\162\155\000\000\000\000\000\032\000"
	+ "\010\000\032\000\001\001\000\001\002\000\001\016\000\001\026"
	+ "\000\001\027\000\001\011\000\001\036\000\001\026\000\005\000"
	+ "\016\000\010\000\004\000\120\000\007\000\010\000\012\000\030"
	+ "\000\021\000\100\000\066\010\252\000\061\001\011\000\033\133"
	+ "\045\160\061\045\144\123\000\172\000\004\000\033\117\105\000"
	+ "\175\000\004\000\033\133\132\000\215\000\004\000\033\117\115"
	+ "\000\067\001\011\000\033\133\045\160\061\045\144\124\000\200"
	+ "\001\013\000\033\133\045\151\045\144\073\045\144\122\000\201"
	+ "\001\005\000\033\133\066\156\000\202\001\023\000\033\133\077"
	+ "\045\133\073\060\061\062\063\064\065\066\067\070\071\135\143"
	+ "\000\203\001\004\000\033\133\143\000\326\000\004\000\033\117"
	+ "\104\000\212\000\004\000\033\117\102\000\351\000\004\000\033"
	+ "\117\103\000\015\001\004\000\033\117\101\000\214\000\004\000"
	+ "\033\117\106\000\323\000\004\000\033\117\110\000\222\000\004"
	+ "\000\033\117\120\000\233\000\006\000\033\133\062\061\176\000"
	+ "\234\000\006\000\033\133\062\063\176\000\235\000\006\000\033"
	+ "\133\062\064\176\000\236\000\007\000\033\133\061\073\062\120"
	+ "\000\237\000\007\000\033\133\061\073\062\121\000\240\000\007"
	+ "\000\033\133\061\073\062\122\000\241\000\007\000\033\133\061"
	+ "\073\062\123\000\242\000\010\000\033\133\061\065\073\062\176"
	+ "\000\243\000\010\000\033\133\061\067\073\062\176\000\244\000"
	+ "\010\000\033\133\061\070\073\062\176\000\223\000\004\000\033"
	+ "\117\121\000\245\000\010\000\033\133\061\071\073\062\176\000"
	+ "\246\000\010\000\033\133\062\060\073\062\176\000\247\000\010"
	+ "\000\033\133\062\061\073\062\176\000\250\000\010\000\033\133"
	+ "\062\063\073\062\176\000\251\000\010\000\033\133\062\064\073"
	+ "\062\176\000\252\000\007\000\033\133\061\073\065\120\000\253"
	+ "\000\007\000\033\133\061\073\065\121\000\254\000\007\000\033"
	+ "\133\061\073\065\122\000\255\000\007\000\033\133\061\073\065"
	+ "\123\000\256\000\010\000\033\133\061\065\073\065\176\000\224"
	+ "\000\004\000\033\117\122\000\257\000\010\000\033\133\061\067"
	+ "\073\065\176\000\260\000\010\000\033\133\061\070\073\065\176"
	+ "\000\261\000\010\000\033\133\061\071\073\065\176\000\262\000"
	+ "\010\000\033\133\062\060\073\065\176\000\263\000\010\000\033"
	+ "\133\062\061\073\065\176\000\264\000\010\000\033\133\062\063"
	+ "\073\065\176\000\265\000\010\000\033\133\062\064\073\065\176"
	+ "\000\266\000\007\000\033\133\061\073\066\120\000\267\000\007"
	+ "\000\033\133\061\073\066\121\000\270\000\007\000\033\133\061"
	+ "\073\066\122\000\225\000\004\000\033\117\123\000\271\000\007"
	+ "\000\033\133\061\073\066\123\000\272\000\010\000\033\133\061"
	+ "\065\073\066\176\000\273\000\010\000\033\133\061\067\073\066"
	+ "\176\000\274\000\010\000\033\133\061\070\073\066\176\000\275"
	+ "\000\010\000\033\133\061\071\073\066\176\000\276\000\010\000"
	+ "\033\133\062\060\073\066\176\000\277\000\010\000\033\133\062"
	+ "\061\073\066\176\000\300\000\010\000\033\133\062\063\073\066"
	+ "\176\000\301\000\010\000\033\133\062\064\073\066\176\000\302"
	+ "\000\007\000\033\133\061\073\063\120\000\226\000\006\000\033"
	+ "\133\061\065\176\000\303\000\007\000\033\133\061\073\063\121"
	+ "\000\304\000\007\000\033\133\061\073\063\122\000\305\000\007"
	+ "\000\033\133\061\073\063\123\000\306\000\010\000\033\133\061"
	+ "\065\073\063\176\000\307\000\010\000\033\133\061\067\073\063"
	+ "\176\000\310\000\010\000\033\133\061\070\073\063\176\000\311"
	+ "\000\010\000\033\133\061\071\073\063\176\000\312\000\010\000"
	+ "\033\133\062\060\073\063\176\000\313\000\010\000\033\133\062"
	+ "\061\073\063\176\000\314\000\010\000\033\133\062\063\073\063"
	+ "\176\000\227\000\006\000\033\133\061\067\176\000\315\000\010"
	+ "\000\033\133\062\064\073\063\176\000\316\000\007\000\033\133"
	+ "\061\073\064\120\000\317\000\007\000\033\133\061\073\064\121"
	+ "\000\320\000\007\000\033\133\061\073\064\122\000\230\000\006"
	+ "\000\033\133\061\070\176\000\231\000\006\000\033\133\061\071"
	+ "\176\000\232\000\006\000\033\133\062\060\176\000\373\000\007"
	+ "\000\033\133\061\073\062\104\000\005\001\007\000\033\133\061"
	+ "\073\062\103\000\366\000\007\000\033\133\061\073\062\102\000"
	+ "\002\001\007\000\033\133\061\073\062\101\000\360\000\007\000"
	+ "\033\133\063\073\062\176\000\363\000\007\000\033\133\061\073"
	+ "\062\106\000\371\000\007\000\033\133\061\073\062\110\000\372"
	+ "\000\007\000\033\133\062\073\062\176\000\376\000\007\000\033"
	+ "\133\066\073\062\176\000\000\001\007\000\033\133\065\073\062"
	+ "\176\000\324\000\005\000\033\133\062\176\000\335\000\005\000"
	+ "\033\133\066\176\000\340\000\005\000\033\133\065\176\000\210"
	+ "\000\005\000\033\133\063\176\000\000\000\065\000\140\140\141"
	+ "\141\146\146\147\147\151\151\152\152\153\153\154\154\155\155"
	+ "\156\156\157\157\160\160\161\161\162\162\163\163\164\164\165"
	+ "\165\166\166\167\167\170\170\171\171\172\172\173\173\174\174"
	+ "\175\175\176\176\000\003\000\002\000\007\000\063\000\005\000"
	+ "\033\133\065\155\000\064\000\005\000\033\133\061\155\000\002"
	+ "\000\004\000\033\133\132\000\035\000\007\000\033\133\077\062"
	+ "\065\154\000\021\000\010\000\033\133\110\033\133\062\112\000"
	+ "\040\000\015\000\033\133\077\061\062\154\033\133\077\062\065"
	+ "\150\000\007\000\002\000\015\000\014\000\021\000\033\133\045"
	+ "\151\045\160\061\045\144\073\045\160\062\045\144\162\000\063"
	+ "\001\011\000\033\133\045\160\061\045\144\104\000\036\000\002"
	+ "\000\010\000\056\001\011\000\033\133\045\160\061\045\144\102"
	+ "\000\033\000\002\000\012\000\065\001\011\000\033\133\045\160"
	+ "\061\045\144\103\000\041\000\004\000\033\133\103\000\032\000"
	+ "\021\000\033\133\045\151\045\160\061\045\144\073\045\160\062"
	+ "\045\144\110\000\070\001\011\000\033\133\045\160\061\045\144"
	+ "\101\000\043\000\004\000\033\133\101\000\044\000\012\000\033"
	+ "\133\077\061\062\073\062\065\150\000\054\001\011\000\033\133"
	+ "\045\160\061\045\144\120\000\047\000\004\000\033\133\120\000"
	+ "\067\000\005\000\033\133\062\155\000\055\001\011\000\033\133"
	+ "\045\160\061\045\144\115\000\050\000\004\000\033\133\115\000"
	+ "\122\000\011\000\033\133\045\160\061\045\144\130\000\024\000"
	+ "\004\000\033\133\112\000\023\000\004\000\033\133\113\000\022"
	+ "\000\005\000\033\133\061\113\000\150\000\022\000\033\133\077"
	+ "\065\150\044\074\061\060\060\057\076\033\133\077\065\154\000"
	+ "\034\000\004\000\033\133\110\000\027\000\013\000\033\133\045"
	+ "\151\045\160\061\045\144\107\000\166\001\002\000\011\000\153"
	+ "\001\003\000\033\110\000\060\001\011\000\033\133\045\160\061"
	+ "\045\144\100\000\062\001\011\000\033\133\045\160\061\045\144"
	+ "\114\000\166\000\004\000\033\133\114\000\122\001\002\000\012"
	+ "\000\110\000\005\000\033\133\070\155\000\157\000\022\000\033"
	+ "\133\041\160\033\133\077\063\073\064\154\033\133\064\154\033"
	+ "\076\000\332\000\004\000\033\133\115\000\052\001\011\000\033"
	+ "\133\063\071\073\064\071\155\000\116\001\003\000\033\070\000"
	+ "\105\000\005\000\033\133\067\155\000\123\001\003\000\033\115"
	+ "\000\132\000\006\000\033\133\062\063\155\000\123\000\004\000"
	+ "\033\050\102\000\124\000\006\000\033\133\077\067\154\000\126"
	+ "\000\011\000\033\133\077\061\060\064\071\154\000\131\000\005"
	+ "\000\033\133\064\154\000\016\001\010\000\033\133\077\061\154"
	+ "\033\076\000\036\001\011\000\033\133\077\061\060\063\064\154"
	+ "\000\140\000\006\000\033\133\062\067\155\000\143\000\006\000"
	+ "\033\133\062\064\155\000\112\001\003\000\033\143\000\113\001"
	+ "\022\000\033\133\041\160\033\133\077\063\073\064\154\033\133"
	+ "\064\154\033\076\000\120\001\003\000\033\067\000\132\001\012"
	+ "\000\033\133\064\045\160\061\045\144\155\000\133\001\012\000"
	+ "\033\133\063\045\160\061\045\144\155\000\135\001\106\000\033"
	+ "\133\064\045\077\045\160\061\045\173\061\175\045\075\045\164"
	+ "\064\045\145\045\160\061\045\173\063\175\045\075\045\164\066"
	+ "\045\145\045\160\061\045\173\064\175\045\075\045\164\061\045"
	+ "\145\045\160\061\045\173\066\175\045\075\045\164\063\045\145"
	+ "\045\160\061\045\144\045\073\155\000\143\001\106\000\033\133"
	+ "\063\045\077\045\160\061\045\173\061\175\045\075\045\164\064"
	+ "\045\145\045\160\061\045\173\063\175\045\075\045\164\066\045"
	+ "\145\045\160\061\045\173\064\175\045\075\045\164\061\045\145"
	+ "\045\160\061\045\173\066\175\045\075\045\164\063\045\145\045"
	+ "\160\061\045\144\045\073\155\000\134\001\135\000\045\077\045"
	+ "\160\071\045\164\033\050\060\045\145\033\050\102\045\073\033"
	+ "\133\060\045\077\045\160\066\045\164\073\061\045\073\045\077"
	+ "\045\160\065\045\164\073\062\045\073\045\077\045\160\062\045"
	+ "\164\073\064\045\073\045\077\045\160\061\045\160\063\045\174"
	+ "\045\164\073\067\045\073\045\077\045\160\064\045\164\073\065"
	+ "\045\073\045\077\045\160\067\045\164\073\070\045\073\155\000"
	+ "\125\000\007\000\033\050\102\033\133\155\000\074\000\005\000"
	+ "\033\133\063\155\000\061\000\004\000\033\050\060\000\062\000"
	+ "\006\000\033\133\077\067\150\000\065\000\011\000\033\133\077"
	+ "\061\060\064\071\150\000\073\000\005\000\033\133\064\150\000"
	+ "\017\001\010\000\033\133\077\061\150\033\075\000\037\001\011"
	+ "\000\033\133\077\061\060\063\064\150\000\112\000\005\000\033"
	+ "\133\067\155\000\116\000\005\000\033\133\064\155\000\017\000"
	+ "\005\000\033\133\063\147\000\117\001\013\000\033\133\045\151"
	+ "\045\160\061\045\144\144\000\100\001\004\000\033\133\151\000"
	+ "\102\001\005\000\033\133\064\151\000\103\001\005\000\033\133"
	+ "\065\151\000\173\000\002\000\010\000\053\004\077\000\004\000"
	+ "\153\104\116\000\163\007\000\033\133\061\073\062\102\000\005"
	+ "\000\153\104\116\063\000\163\007\000\033\133\061\073\063\102"
	+ "\000\005\000\153\104\116\064\000\163\007\000\033\133\061\073"
	+ "\064\102\000\005\000\153\104\116\065\000\163\007\000\033\133"
	+ "\061\073\065\102\000\005\000\153\104\116\066\000\163\007\000"
	+ "\033\133\061\073\066\102\000\005\000\153\104\116\067\000\163"
	+ "\007\000\033\133\061\073\067\102\000\006\000\153\114\106\124"
	+ "\063\000\163\007\000\033\133\061\073\063\104\000\006\000\153"
	+ "\114\106\124\064\000\163\007\000\033\133\061\073\064\104\000"
	+ "\006\000\153\114\106\124\065\000\163\007\000\033\133\061\073"
	+ "\065\104\000\006\000\153\114\106\124\066\000\163\007\000\033"
	+ "\133\061\073\066\104\000\006\000\153\114\106\124\067\000\163"
	+ "\007\000\033\133\061\073\067\104\000\006\000\153\122\111\124"
	+ "\063\000\163\007\000\033\133\061\073\063\103\000\006\000\153"
	+ "\122\111\124\064\000\163\007\000\033\133\061\073\064\103\000"
	+ "\006\000\153\122\111\124\065\000\163\007\000\033\133\061\073"
	+ "\065\103\000\006\000\153\122\111\124\066\000\163\007\000\033"
	+ "\133\061\073\066\103\000\006\000\153\122\111\124\067\000\163"
	+ "\007\000\033\133\061\073\067\103\000\004\000\153\125\120\000"
	+ "\163\007\000\033\133\061\073\062\101\000\005\000\153\125\120"
	+ "\063\000\163\007\000\033\133\061\073\063\101\000\005\000\153"
	+ "\125\120\064\000\163\007\000\033\133\061\073\064\101\000\005"
	+ "\000\153\125\120\065\000\163\007\000\033\133\061\073\065\101"
	+ "\000\005\000\153\125\120\066\000\163\007\000\033\133\061\073"
	+ "\066\101\000\005\000\153\125\120\067\000\163\007\000\033\133"
	+ "\061\073\067\101\000\005\000\153\104\103\063\000\163\007\000"
	+ "\033\133\063\073\063\176\000\005\000\153\104\103\064\000\163"
	+ "\007\000\033\133\063\073\064\176\000\005\000\153\104\103\065"
	+ "\000\163\007\000\033\133\063\073\065\176\000\005\000\153\104"
	+ "\103\066\000\163\007\000\033\133\063\073\066\176\000\005\000"
	+ "\153\104\103\067\000\163\007\000\033\133\063\073\067\176\000"
	+ "\006\000\153\105\116\104\063\000\163\007\000\033\133\061\073"
	+ "\063\106\000\006\000\153\105\116\104\064\000\163\007\000\033"
	+ "\133\061\073\064\106\000\006\000\153\105\116\104\065\000\163"
	+ "\007\000\033\133\061\073\065\106\000\006\000\153\105\116\104"
	+ "\066\000\163\007\000\033\133\061\073\066\106\000\006\000\153"
	+ "\105\116\104\067\000\163\007\000\033\133\061\073\067\106\000"
	+ "\006\000\153\110\117\115\063\000\163\007\000\033\133\061\073"
	+ "\063\110\000\006\000\153\110\117\115\064\000\163\007\000\033"
	+ "\133\061\073\064\110\000\006\000\153\110\117\115\065\000\163"
	+ "\007\000\033\133\061\073\065\110\000\006\000\153\110\117\115"
	+ "\066\000\163\007\000\033\133\061\073\066\110\000\006\000\153"
	+ "\110\117\115\067\000\163\007\000\033\133\061\073\067\110\000"
	+ "\005\000\153\111\103\063\000\163\007\000\033\133\062\073\063"
	+ "\176\000\005\000\153\111\103\064\000\163\007\000\033\133\062"
	+ "\073\064\176\000\005\000\153\111\103\065\000\163\007\000\033"
	+ "\133\062\073\065\176\000\005\000\153\111\103\066\000\163\007"
	+ "\000\033\133\062\073\066\176\000\005\000\153\111\103\067\000"
	+ "\163\007\000\033\133\062\073\067\176\000\006\000\153\116\130"
	+ "\124\063\000\163\007\000\033\133\066\073\063\176\000\006\000"
	+ "\153\116\130\124\064\000\163\007\000\033\133\066\073\064\176"
	+ "\000\006\000\153\116\130\124\065\000\163\007\000\033\133\066"
	+ "\073\065\176\000\006\000\153\116\130\124\066\000\163\007\000"
	+ "\033\133\066\073\066\176\000\006\000\153\116\130\124\067\000"
	+ "\163\007\000\033\133\066\073\067\176\000\006\000\153\120\122"
	+ "\126\063\000\163\007\000\033\133\065\073\063\176\000\006\000"
	+ "\153\120\122\126\064\000\163\007\000\033\133\065\073\064\176"
	+ "\000\006\000\153\120\122\126\065\000\163\007\000\033\133\065"
	+ "\073\065\176\000\006\000\153\120\122\126\066\000\163\007\000"
	+ "\033\133\065\073\066\176\000\006\000\153\120\122\126\067\000"
	+ "\163\007\000\033\133\065\073\067\176\000\003\000\103\162\000"
	+ "\163\007\000\033\135\061\061\062\007\000\003\000\103\163\000"
	+ "\163\014\000\033\135\061\062\073\045\160\061\045\163\007\000"
	+ "\003\000\115\163\000\163\022\000\033\135\065\062\073\045\160"
	+ "\061\045\163\073\045\160\062\045\163\007\000\003\000\123\145"
	+ "\000\163\006\000\033\133\062\040\161\000\003\000\123\163\000"
	+ "\163\012\000\033\133\045\160\061\045\144\040\161\000\003\000"
	+ "\142\163\000\146\001\003\000\101\130\000\146\001\003\000\130"
	+ "\124\000\146\001\005\000\155\145\155\154\000\163\003\000\033"
	+ "\154\000\005\000\155\145\155\165\000\163\003\000\033\155\000"
	+ "\003\000\105\063\000\163\005\000\033\133\063\112\000",
	+ 3238
	+ },
	+ {
	+ "xterm-256color",
	+ "\001\017\000\170\164\145\162\155\055\062\065\066\143\157\154"
	+ "\157\162\000\000\000\000\000\035\000\011\000\003\000\001\032"
	+ "\000\001\001\000\001\002\000\001\016\000\001\026\000\001\027"
	+ "\000\001\011\000\001\036\000\001\026\000\005\000\016\000\000"
	+ "\001\021\000\377\177\004\000\120\000\007\000\010\000\012\000"
	+ "\030\000\024\011\254\000\112\001\011\000\033\143\033\135\061"
	+ "\060\064\007\000\163\000\136\000\033\135\064\073\045\160\061"
	+ "\045\144\073\162\147\142\072\045\160\062\045\173\062\065\065"
	+ "\175\045\052\045\173\061\060\060\060\175\045\057\045\062\056"
	+ "\062\130\057\045\160\063\045\173\062\065\065\175\045\052\045"
	+ "\173\061\060\060\060\175\045\057\045\062\056\062\130\057\045"
	+ "\160\064\045\173\062\065\065\175\045\052\045\173\061\060\060"
	+ "\060\175\045\057\045\062\056\062\130\033\134\000\051\001\007"
	+ "\000\033\135\061\060\064\007\000\132\001\100\000\033\133\045"
	+ "\077\045\160\061\045\173\070\175\045\074\045\164\064\045\160"
	+ "\061\045\144\045\145\045\160\061\045\173\061\066\175\045\074"
	+ "\045\164\061\060\045\160\061\045\173\070\175\045\055\045\144"
	+ "\045\145\064\070\073\065\073\045\160\061\045\144\045\073\155"
	+ "\000\133\001\077\000\033\133\045\077\045\160\061\045\173\070"
	+ "\175\045\074\045\164\063\045\160\061\045\144\045\145\045\160"
	+ "\061\045\173\061\066\175\045\074\045\164\071\045\160\061\045"
	+ "\173\070\175\045\055\045\144\045\145\063\070\073\065\073\045"
	+ "\160\061\045\144\045\073\155\000\061\001\011\000\033\133\045"
	+ "\160\061\045\144\123\000\172\000\004\000\033\117\105\000\175"
	+ "\000\004\000\033\133\132\000\215\000\004\000\033\117\115\000"
	+ "\067\001\011\000\033\133\045\160\061\045\144\124\000\200\001"
	+ "\013\000\033\133\045\151\045\144\073\045\144\122\000\201\001"
	+ "\005\000\033\133\066\156\000\202\001\023\000\033\133\077\045"
	+ "\133\073\060\061\062\063\064\065\066\067\070\071\135\143\000"
	+ "\203\001\004\000\033\133\143\000\326\000\004\000\033\117\104"
	+ "\000\212\000\004\000\033\117\102\000\351\000\004\000\033\117"
	+ "\103\000\015\001\004\000\033\117\101\000\214\000\004\000\033"
	+ "\117\106\000\323\000\004\000\033\117\110\000\222\000\004\000"
	+ "\033\117\120\000\233\000\006\000\033\133\062\061\176\000\234"
	+ "\000\006\000\033\133\062\063\176\000\235\000\006\000\033\133"
	+ "\062\064\176\000\236\000\007\000\033\133\061\073\062\120\000"
	+ "\237\000\007\000\033\133\061\073\062\121\000\240\000\007\000"
	+ "\033\133\061\073\062\122\000\241\000\007\000\033\133\061\073"
	+ "\062\123\000\242\000\010\000\033\133\061\065\073\062\176\000"
	+ "\243\000\010\000\033\133\061\067\073\062\176\000\244\000\010"
	+ "\000\033\133\061\070\073\062\176\000\223\000\004\000\033\117"
	+ "\121\000\245\000\010\000\033\133\061\071\073\062\176\000\246"
	+ "\000\010\000\033\133\062\060\073\062\176\000\247\000\010\000"
	+ "\033\133\062\061\073\062\176\000\250\000\010\000\033\133\062"
	+ "\063\073\062\176\000\251\000\010\000\033\133\062\064\073\062"
	+ "\176\000\252\000\007\000\033\133\061\073\065\120\000\253\000"
	+ "\007\000\033\133\061\073\065\121\000\254\000\007\000\033\133"
	+ "\061\073\065\122\000\255\000\007\000\033\133\061\073\065\123"
	+ "\000\256\000\010\000\033\133\061\065\073\065\176\000\224\000"
	+ "\004\000\033\117\122\000\257\000\010\000\033\133\061\067\073"
	+ "\065\176\000\260\000\010\000\033\133\061\070\073\065\176\000"
	+ "\261\000\010\000\033\133\061\071\073\065\176\000\262\000\010"
	+ "\000\033\133\062\060\073\065\176\000\263\000\010\000\033\133"
	+ "\062\061\073\065\176\000\264\000\010\000\033\133\062\063\073"
	+ "\065\176\000\265\000\010\000\033\133\062\064\073\065\176\000"
	+ "\266\000\007\000\033\133\061\073\066\120\000\267\000\007\000"
	+ "\033\133\061\073\066\121\000\270\000\007\000\033\133\061\073"
	+ "\066\122\000\225\000\004\000\033\117\123\000\271\000\007\000"
	+ "\033\133\061\073\066\123\000\272\000\010\000\033\133\061\065"
	+ "\073\066\176\000\273\000\010\000\033\133\061\067\073\066\176"
	+ "\000\274\000\010\000\033\133\061\070\073\066\176\000\275\000"
	+ "\010\000\033\133\061\071\073\066\176\000\276\000\010\000\033"
	+ "\133\062\060\073\066\176\000\277\000\010\000\033\133\062\061"
	+ "\073\066\176\000\300\000\010\000\033\133\062\063\073\066\176"
	+ "\000\301\000\010\000\033\133\062\064\073\066\176\000\302\000"
	+ "\007\000\033\133\061\073\063\120\000\226\000\006\000\033\133"
	+ "\061\065\176\000\303\000\007\000\033\133\061\073\063\121\000"
	+ "\304\000\007\000\033\133\061\073\063\122\000\305\000\007\000"
	+ "\033\133\061\073\063\123\000\306\000\010\000\033\133\061\065"
	+ "\073\063\176\000\307\000\010\000\033\133\061\067\073\063\176"
	+ "\000\310\000\010\000\033\133\061\070\073\063\176\000\311\000"
	+ "\010\000\033\133\061\071\073\063\176\000\312\000\010\000\033"
	+ "\133\062\060\073\063\176\000\313\000\010\000\033\133\062\061"
	+ "\073\063\176\000\314\000\010\000\033\133\062\063\073\063\176"
	+ "\000\227\000\006\000\033\133\061\067\176\000\315\000\010\000"
	+ "\033\133\062\064\073\063\176\000\316\000\007\000\033\133\061"
	+ "\073\064\120\000\317\000\007\000\033\133\061\073\064\121\000"
	+ "\320\000\007\000\033\133\061\073\064\122\000\230\000\006\000"
	+ "\033\133\061\070\176\000\231\000\006\000\033\133\061\071\176"
	+ "\000\232\000\006\000\033\133\062\060\176\000\373\000\007\000"
	+ "\033\133\061\073\062\104\000\005\001\007\000\033\133\061\073"
	+ "\062\103\000\366\000\007\000\033\133\061\073\062\102\000\002"
	+ "\001\007\000\033\133\061\073\062\101\000\360\000\007\000\033"
	+ "\133\063\073\062\176\000\363\000\007\000\033\133\061\073\062"
	+ "\106\000\371\000\007\000\033\133\061\073\062\110\000\372\000"
	+ "\007\000\033\133\062\073\062\176\000\376\000\007\000\033\133"
	+ "\066\073\062\176\000\000\001\007\000\033\133\065\073\062\176"
	+ "\000\324\000\005\000\033\133\062\176\000\335\000\005\000\033"
	+ "\133\066\176\000\340\000\005\000\033\133\065\176\000\210\000"
	+ "\005\000\033\133\063\176\000\000\000\065\000\140\140\141\141"
	+ "\146\146\147\147\151\151\152\152\153\153\154\154\155\155\156"
	+ "\156\157\157\160\160\161\161\162\162\163\163\164\164\165\165"
	+ "\166\166\167\167\170\170\171\171\172\172\173\173\174\174\175"
	+ "\175\176\176\000\003\000\002\000\007\000\063\000\005\000\033"
	+ "\133\065\155\000\064\000\005\000\033\133\061\155\000\002\000"
	+ "\004\000\033\133\132\000\035\000\007\000\033\133\077\062\065"
	+ "\154\000\021\000\010\000\033\133\110\033\133\062\112\000\040"
	+ "\000\015\000\033\133\077\061\062\154\033\133\077\062\065\150"
	+ "\000\007\000\002\000\015\000\014\000\021\000\033\133\045\151"
	+ "\045\160\061\045\144\073\045\160\062\045\144\162\000\063\001"
	+ "\011\000\033\133\045\160\061\045\144\104\000\036\000\002\000"
	+ "\010\000\056\001\011\000\033\133\045\160\061\045\144\102\000"
	+ "\033\000\002\000\012\000\065\001\011\000\033\133\045\160\061"
	+ "\045\144\103\000\041\000\004\000\033\133\103\000\032\000\021"
	+ "\000\033\133\045\151\045\160\061\045\144\073\045\160\062\045"
	+ "\144\110\000\070\001\011\000\033\133\045\160\061\045\144\101"
	+ "\000\043\000\004\000\033\133\101\000\044\000\012\000\033\133"
	+ "\077\061\062\073\062\065\150\000\054\001\011\000\033\133\045"
	+ "\160\061\045\144\120\000\047\000\004\000\033\133\120\000\067"
	+ "\000\005\000\033\133\062\155\000\055\001\011\000\033\133\045"
	+ "\160\061\045\144\115\000\050\000\004\000\033\133\115\000\122"
	+ "\000\011\000\033\133\045\160\061\045\144\130\000\024\000\004"
	+ "\000\033\133\112\000\023\000\004\000\033\133\113\000\022\000"
	+ "\005\000\033\133\061\113\000\150\000\022\000\033\133\077\065"
	+ "\150\044\074\061\060\060\057\076\033\133\077\065\154\000\034"
	+ "\000\004\000\033\133\110\000\027\000\013\000\033\133\045\151"
	+ "\045\160\061\045\144\107\000\166\001\002\000\011\000\153\001"
	+ "\003\000\033\110\000\060\001\011\000\033\133\045\160\061\045"
	+ "\144\100\000\062\001\011\000\033\133\045\160\061\045\144\114"
	+ "\000\166\000\004\000\033\133\114\000\122\001\002\000\012\000"
	+ "\110\000\005\000\033\133\070\155\000\157\000\022\000\033\133"
	+ "\041\160\033\133\077\063\073\064\154\033\133\064\154\033\076"
	+ "\000\332\000\004\000\033\133\115\000\052\001\011\000\033\133"
	+ "\063\071\073\064\071\155\000\116\001\003\000\033\070\000\105"
	+ "\000\005\000\033\133\067\155\000\123\001\003\000\033\115\000"
	+ "\132\000\006\000\033\133\062\063\155\000\123\000\004\000\033"
	+ "\050\102\000\124\000\006\000\033\133\077\067\154\000\126\000"
	+ "\011\000\033\133\077\061\060\064\071\154\000\131\000\005\000"
	+ "\033\133\064\154\000\016\001\010\000\033\133\077\061\154\033"
	+ "\076\000\036\001\011\000\033\133\077\061\060\063\064\154\000"
	+ "\140\000\006\000\033\133\062\067\155\000\143\000\006\000\033"
	+ "\133\062\064\155\000\113\001\022\000\033\133\041\160\033\133"
	+ "\077\063\073\064\154\033\133\064\154\033\076\000\120\001\003"
	+ "\000\033\067\000\135\001\106\000\033\133\064\045\077\045\160"
	+ "\061\045\173\061\175\045\075\045\164\064\045\145\045\160\061"
	+ "\045\173\063\175\045\075\045\164\066\045\145\045\160\061\045"
	+ "\173\064\175\045\075\045\164\061\045\145\045\160\061\045\173"
	+ "\066\175\045\075\045\164\063\045\145\045\160\061\045\144\045"
	+ "\073\155\000\143\001\106\000\033\133\063\045\077\045\160\061"
	+ "\045\173\061\175\045\075\045\164\064\045\145\045\160\061\045"
	+ "\173\063\175\045\075\045\164\066\045\145\045\160\061\045\173"
	+ "\064\175\045\075\045\164\061\045\145\045\160\061\045\173\066"
	+ "\175\045\075\045\164\063\045\145\045\160\061\045\144\045\073"
	+ "\155\000\134\001\135\000\045\077\045\160\071\045\164\033\050"
	+ "\060\045\145\033\050\102\045\073\033\133\060\045\077\045\160"
	+ "\066\045\164\073\061\045\073\045\077\045\160\065\045\164\073"
	+ "\062\045\073\045\077\045\160\062\045\164\073\064\045\073\045"
	+ "\077\045\160\061\045\160\063\045\174\045\164\073\067\045\073"
	+ "\045\077\045\160\064\045\164\073\065\045\073\045\077\045\160"
	+ "\067\045\164\073\070\045\073\155\000\125\000\007\000\033\050"
	+ "\102\033\133\155\000\074\000\005\000\033\133\063\155\000\061"
	+ "\000\004\000\033\050\060\000\062\000\006\000\033\133\077\067"
	+ "\150\000\065\000\011\000\033\133\077\061\060\064\071\150\000"
	+ "\073\000\005\000\033\133\064\150\000\017\001\010\000\033\133"
	+ "\077\061\150\033\075\000\037\001\011\000\033\133\077\061\060"
	+ "\063\064\150\000\112\000\005\000\033\133\067\155\000\116\000"
	+ "\005\000\033\133\064\155\000\017\000\005\000\033\133\063\147"
	+ "\000\117\001\013\000\033\133\045\151\045\160\061\045\144\144"
	+ "\000\100\001\004\000\033\133\151\000\102\001\005\000\033\133"
	+ "\064\151\000\103\001\005\000\033\133\065\151\000\173\000\002"
	+ "\000\010\000\053\004\077\000\004\000\153\104\116\000\163\007"
	+ "\000\033\133\061\073\062\102\000\005\000\153\104\116\063\000"
	+ "\163\007\000\033\133\061\073\063\102\000\005\000\153\104\116"
	+ "\064\000\163\007\000\033\133\061\073\064\102\000\005\000\153"
	+ "\104\116\065\000\163\007\000\033\133\061\073\065\102\000\005"
	+ "\000\153\104\116\066\000\163\007\000\033\133\061\073\066\102"
	+ "\000\005\000\153\104\116\067\000\163\007\000\033\133\061\073"
	+ "\067\102\000\006\000\153\114\106\124\063\000\163\007\000\033"
	+ "\133\061\073\063\104\000\006\000\153\114\106\124\064\000\163"
	+ "\007\000\033\133\061\073\064\104\000\006\000\153\114\106\124"
	+ "\065\000\163\007\000\033\133\061\073\065\104\000\006\000\153"
	+ "\114\106\124\066\000\163\007\000\033\133\061\073\066\104\000"
	+ "\006\000\153\114\106\124\067\000\163\007\000\033\133\061\073"
	+ "\067\104\000\006\000\153\122\111\124\063\000\163\007\000\033"
	+ "\133\061\073\063\103\000\006\000\153\122\111\124\064\000\163"
	+ "\007\000\033\133\061\073\064\103\000\006\000\153\122\111\124"
	+ "\065\000\163\007\000\033\133\061\073\065\103\000\006\000\153"
	+ "\122\111\124\066\000\163\007\000\033\133\061\073\066\103\000"
	+ "\006\000\153\122\111\124\067\000\163\007\000\033\133\061\073"
	+ "\067\103\000\004\000\153\125\120\000\163\007\000\033\133\061"
	+ "\073\062\101\000\005\000\153\125\120\063\000\163\007\000\033"
	+ "\133\061\073\063\101\000\005\000\153\125\120\064\000\163\007"
	+ "\000\033\133\061\073\064\101\000\005\000\153\125\120\065\000"
	+ "\163\007\000\033\133\061\073\065\101\000\005\000\153\125\120"
	+ "\066\000\163\007\000\033\133\061\073\066\101\000\005\000\153"
	+ "\125\120\067\000\163\007\000\033\133\061\073\067\101\000\005"
	+ "\000\153\104\103\063\000\163\007\000\033\133\063\073\063\176"
	+ "\000\005\000\153\104\103\064\000\163\007\000\033\133\063\073"
	+ "\064\176\000\005\000\153\104\103\065\000\163\007\000\033\133"
	+ "\063\073\065\176\000\005\000\153\104\103\066\000\163\007\000"
	+ "\033\133\063\073\066\176\000\005\000\153\104\103\067\000\163"
	+ "\007\000\033\133\063\073\067\176\000\006\000\153\105\116\104"
	+ "\063\000\163\007\000\033\133\061\073\063\106\000\006\000\153"
	+ "\105\116\104\064\000\163\007\000\033\133\061\073\064\106\000"
	+ "\006\000\153\105\116\104\065\000\163\007\000\033\133\061\073"
	+ "\065\106\000\006\000\153\105\116\104\066\000\163\007\000\033"
	+ "\133\061\073\066\106\000\006\000\153\105\116\104\067\000\163"
	+ "\007\000\033\133\061\073\067\106\000\006\000\153\110\117\115"
	+ "\063\000\163\007\000\033\133\061\073\063\110\000\006\000\153"
	+ "\110\117\115\064\000\163\007\000\033\133\061\073\064\110\000"
	+ "\006\000\153\110\117\115\065\000\163\007\000\033\133\061\073"
	+ "\065\110\000\006\000\153\110\117\115\066\000\163\007\000\033"
	+ "\133\061\073\066\110\000\006\000\153\110\117\115\067\000\163"
	+ "\007\000\033\133\061\073\067\110\000\005\000\153\111\103\063"
	+ "\000\163\007\000\033\133\062\073\063\176\000\005\000\153\111"
	+ "\103\064\000\163\007\000\033\133\062\073\064\176\000\005\000"
	+ "\153\111\103\065\000\163\007\000\033\133\062\073\065\176\000"
	+ "\005\000\153\111\103\066\000\163\007\000\033\133\062\073\066"
	+ "\176\000\005\000\153\111\103\067\000\163\007\000\033\133\062"
	+ "\073\067\176\000\006\000\153\116\130\124\063\000\163\007\000"
	+ "\033\133\066\073\063\176\000\006\000\153\116\130\124\064\000"
	+ "\163\007\000\033\133\066\073\064\176\000\006\000\153\116\130"
	+ "\124\065\000\163\007\000\033\133\066\073\065\176\000\006\000"
	+ "\153\116\130\124\066\000\163\007\000\033\133\066\073\066\176"
	+ "\000\006\000\153\116\130\124\067\000\163\007\000\033\133\066"
	+ "\073\067\176\000\006\000\153\120\122\126\063\000\163\007\000"
	+ "\033\133\065\073\063\176\000\006\000\153\120\122\126\064\000"
	+ "\163\007\000\033\133\065\073\064\176\000\006\000\153\120\122"
	+ "\126\065\000\163\007\000\033\133\065\073\065\176\000\006\000"
	+ "\153\120\122\126\066\000\163\007\000\033\133\065\073\066\176"
	+ "\000\006\000\153\120\122\126\067\000\163\007\000\033\133\065"
	+ "\073\067\176\000\003\000\103\162\000\163\007\000\033\135\061"
	+ "\061\062\007\000\003\000\103\163\000\163\014\000\033\135\061"
	+ "\062\073\045\160\061\045\163\007\000\003\000\115\163\000\163"
	+ "\022\000\033\135\065\062\073\045\160\061\045\163\073\045\160"
	+ "\062\045\163\007\000\003\000\123\145\000\163\006\000\033\133"
	+ "\062\040\161\000\003\000\123\163\000\163\012\000\033\133\045"
	+ "\160\061\045\144\040\161\000\003\000\142\163\000\146\001\003"
	+ "\000\101\130\000\146\001\003\000\130\124\000\146\001\005\000"
	+ "\155\145\155\154\000\163\003\000\033\154\000\005\000\155\145"
	+ "\155\165\000\163\003\000\033\155\000\003\000\105\063\000\163"
	+ "\005\000\033\133\063\112\000",
	+ 3472
	+ }
	+};
	Index: contrib/mg/configure
	===================================================================
	--- /dev/null
	+++ contrib/mg/configure
	@@ -0,0 +1,594 @@
	+#!/bin/sh
	+
	+# This configure script written by Brian Callahan <bcallah@openbsd.org>
	+# and released into the Public Domain.
	+
	+cccheck() {
	+ if [ ! -z "$CC" ] ; then
	+cat << EOF > conftest.c
	+int main(void){return 0;}
	+EOF
	+ $CC -o conftest conftest.c > /dev/null 2>&1
	+ if [ $? -eq 0 ] ; then
	+ ./conftest
	+ if [ $? -eq 0 ] ; then
	+ rm -f conftest conftest.c
	+ cc="$CC"
	+ return 0
	+ else
	+ echo "could not build working executables"
	+ echo "Please ensure your C compiler is a native compiler"
	+ exit 1
	+ fi
	+ else
	+ rm -f conftest conftest.c
	+ fi
	+ fi
	+
	+ for compiler in cc clang pcc xlc gcc ; do
	+cat << EOF > conftest.c
	+int main(void){return 0;}
	+EOF
	+
	+ $compiler -o conftest conftest.c > /dev/null 2>&1
	+
	+ if [ $? -eq 0 ] ; then
	+ ./conftest
	+ if [ $? -eq 0 ] ; then
	+ rm -f conftest conftest.c
	+ cc="$compiler"
	+ return 0
	+ else
	+ echo "could not build working executables"
	+ echo "Please ensure your C compiler is a native compiler"
	+ exit 1
	+ fi
	+ else
	+ rm -f conftest conftest.c
	+ fi
	+ done
	+ return 1
	+}
	+
	+defaultcflagscheck() {
	+ cat << EOF > conftest.c
	+int main(void){return 0;}
	+EOF
	+ $cc $cflags -g -O2 -o conftest.o -c conftest.c > /dev/null 2>&1
	+ if [ $? -eq 0 ] ; then
	+ rm -f conftest conftest.o conftest.c
	+ return 1
	+ else
	+ rm -f conftest conftest.o conftest.c
	+ return 0
	+ fi
	+}
	+
	+fparselncheck() {
	+ cat << EOF > conftest.c
	+#include <stdio.h>
	+#if defined(__APPLE__)
	+#include "apple.h"
	+#elif defined(__linux__)
	+#include "util.h"
	+#elif defined(__FreeBSD__)
	+#include <libutil.h>
	+#else
	+#include <util.h>
	+#endif
	+int main(void){fparseln(NULL,NULL,NULL,NULL,0);return 0;}
	+EOF
	+ $cc $tflags -o conftest conftest.c $libs > /dev/null 2>&1
	+ if [ $? -eq 0 ] ; then
	+ rm -f conftest conftest.c
	+ return 0
	+ else
	+ rm -f conftest conftest.c
	+ return 1
	+ fi
	+}
	+
	+fstatatcheck() {
	+ cat << EOF > conftest.c
	+#undef _POSIX_C_SOURCE
	+#define _POSIX_C_SOURCE 200809L
	+#include <sys/stat.h>
	+#include <fcntl.h>
	+#include <stdio.h>
	+int main(void){fstatat(0, NULL, NULL, 0);return 0;}
	+EOF
	+ $cc $tflags -o conftest conftest.c > /dev/null 2>&1
	+ if [ $? -eq 0 ] ; then
	+ rm -f conftest conftest.c
	+ return 0
	+ else
	+ rm -f conftest conftest.c
	+ return 1
	+ fi
	+}
	+
	+futimenscheck() {
	+ cat << EOF > conftest.c
	+#include <sys/stat.h>
	+#include <fcntl.h>
	+#include <stdio.h>
	+int main(void){futimens(0, NULL);return 0;}
	+EOF
	+ $cc $tflags -o conftest conftest.c > /dev/null 2>&1
	+ if [ $? -eq 0 ] ; then
	+ rm -f conftest conftest.c
	+ return 0
	+ else
	+ rm -f conftest conftest.c
	+ return 1
	+ fi
	+}
	+
	+getlinecheck() {
	+ cat << EOF > conftest.c
	+#include <stdio.h>
	+int main(void){getline(NULL,NULL,NULL);return 0;}
	+EOF
	+ $cc $tflags -o conftest conftest.c > /dev/null 2>&1
	+ if [ $? -eq 0 ] ; then
	+ rm -f conftest conftest.c
	+ return 0
	+ else
	+ rm -f conftest conftest.c
	+ return 1
	+ fi
	+}
	+
	+pledgecheck() {
	+ cat << EOF > conftest.c
	+#include <unistd.h>
	+int main(void){pledge(NULL,NULL);return 0;}
	+EOF
	+ $cc $tflags -o conftest conftest.c > /dev/null 2>&1
	+ if [ $? -eq 0 ] ; then
	+ rm -f conftest conftest.c
	+ return 0
	+ else
	+ rm -f conftest conftest.c
	+ return 1
	+ fi
	+}
	+
	+reallocarraycheck() {
	+ cat << EOF > conftest.c
	+#include <stdlib.h>
	+int main(void){reallocarray(NULL, 0, 0);return 0;}
	+EOF
	+ $cc $tflags -o conftest conftest.c > /dev/null 2>&1
	+ if [ $? -eq 0 ] ; then
	+ rm -f conftest conftest.c
	+ return 0
	+ else
	+ rm -f conftest conftest.c
	+ return 1
	+ fi
	+}
	+
	+strlcatcheck() {
	+ cat << EOF > conftest.c
	+#include <string.h>
	+int main(void){strlcat(NULL,NULL,0);return 0;}
	+EOF
	+ $cc $tflags -o conftest conftest.c > /dev/null 2>&1
	+ if [ $? -eq 0 ] ; then
	+ rm -f conftest conftest.c
	+ return 0
	+ else
	+ rm -f conftest conftest.c
	+ return 1
	+ fi
	+}
	+
	+strlcpycheck() {
	+ cat << EOF > conftest.c
	+#include <string.h>
	+int main(void){strlcpy(NULL,NULL,0);return 0;}
	+EOF
	+ $cc $tflags -o conftest conftest.c > /dev/null 2>&1
	+ if [ $? -eq 0 ] ; then
	+ rm -f conftest conftest.c
	+ return 0
	+ else
	+ rm -f conftest conftest.c
	+ return 1
	+ fi
	+}
	+
	+strndupcheck() {
	+ cat << EOF > conftest.c
	+#include <string.h>
	+int main(void){strndup(NULL,0);return 0;}
	+EOF
	+ $cc $tflags -o conftest conftest.c > /dev/null 2>&1
	+ if [ $? -eq 0 ] ; then
	+ rm -f conftest conftest.c
	+ return 0
	+ else
	+ rm -f conftest conftest.c
	+ return 1
	+ fi
	+}
	+
	+strtonumcheck() {
	+ cat << EOF > conftest.c
	+#include <stdlib.h>
	+int main(void){strtonum(NULL, 0, 0, NULL);return 0;}
	+EOF
	+ $cc $tflags -o conftest conftest.c > /dev/null 2>&1
	+ if [ $? -eq 0 ] ; then
	+ rm -f conftest conftest.c
	+ return 0
	+ else
	+ rm -f conftest conftest.c
	+ return 1
	+ fi
	+}
	+
	+wflagcheck() {
	+ cat << EOF > conftest.c
	+int main(void){return 0;}
	+EOF
	+ $cc $cflags -w -o conftest conftest.c > /dev/null 2>&1
	+ if [ $? -eq 0 ] ; then
	+ rm -f conftest conftest.o conftest.c
	+ return 1
	+ else
	+ rm -f conftest conftest.o conftest.c
	+ return 0
	+ fi
	+}
	+
	+# Option variables
	+if [ ! -z "$PREFIX" ] ; then
	+ prefix="$PREFIX"
	+else
	+ prefix="/usr/local"
	+fi
	+
	+mandir="$prefix/man"
	+
	+prog="mg"
	+log=0
	+static=0
	+terminfo=0
	+
	+# Options
	+for opt
	+do
	+ case "$opt" in
	+ --prefix=*)
	+ prefix=`echo $opt \| cut -d '=' -f 2`
	+ ;;
	+ --mandir=*)
	+ mandir=`echo $opt \| cut -d '=' -f 2`
	+ ;;
	+ --disable-logging\|--enable-logging)
	+ if [ "x$opt" = "x--enable-logging" ] ; then
	+ log=1
	+ else
	+ log=0
	+ fi
	+ ;;
	+ --disable-static\|--enable-static)
	+ if [ "x$opt" = "x--enable-static" ] ; then
	+ static=1
	+ else
	+ static=0
	+ fi
	+ ;;
	+ --with-builtin-curses\|--without-builtin-curses)
	+ if [ "x$opt" = "x--with-builtin-curses" ] ; then
	+ terminfo=1
	+ else
	+ terminfo=0
	+ fi
	+ ;;
	+ --help\|-h)
	+ echo "Usage: configure [options]"
	+ echo ""
	+ echo "Options:"
	+ printf " --help or -h "
	+ echo "Display this help message"
	+ printf " --prefix=PREFIX "
	+ echo "Top level install directory is PREFIX [$prefix]"
	+ printf " --mandir=MANDIR "
	+ echo "Manual pages are installed to MANDIR [$mandir]"
	+ printf " --enable-logging "
	+ echo "Enable run-time debugging [default=no]"
	+ printf " --enable-static "
	+ echo "Statically link executables [default=no]"
	+ printf " --with-builtin-curses "
	+ echo "Compile with builtin curses library [default=no]"
	+ exit 1
	+ ;;
	+ *)
	+ ;;
	+ esac
	+done
	+
	+if [ ! -z "$CFLAGS" ] ; then
	+ cflags="$CFLAGS -DREGEX"
	+else
	+ cflags="-DREGEX"
	+fi
	+
	+if [ ! -z "$LDFLAGS" ] ; then
	+ ldflags="$LDFLAGS "
	+else
	+ ldflags=""
	+fi
	+
	+if [ $static -ne 0 ] ; then
	+ ldflags="${ldflags}-static"
	+fi
	+
	+printf "checking for C compiler... "
	+cccheck
	+if [ $? -ne 0 ] ; then
	+ echo "not found"
	+ echo "Please install a C compiler and re-run configure."
	+ exit 1
	+else
	+ echo "$cc"
	+fi
	+
	+if [ "x$cflags" = "x-DREGEX" ] ; then
	+ printf "checking if the compiler accepts -g -O2... "
	+ defaultcflagscheck
	+ if [ $? -eq 0 ] ; then
	+ echo "no"
	+ else
	+ cflags="-g -O2 $cflags"
	+ echo "yes"
	+ fi
	+fi
	+
	+printf "checking for -w compiler flag... "
	+wflagcheck
	+if [ $? -eq 0 ] ; then
	+ echo "no"
	+else
	+ cflags="$cflags -w"
	+ echo "yes"
	+fi
	+
	+printf "checking for OS... "
	+
	+if [ $terminfo -eq 0 ] ; then
	+ libs="-lncursesw"
	+else
	+ libs=""
	+fi
	+
	+os=`uname -s`
	+echo "$os"
	+
	+case "x$os" in
	+ "xLinux"\|"xCYGWIN"*)
	+ cflags="$cflags -D_GNU_SOURCE -D__dead=\"__attribute__((__noreturn__))\" -Dst_mtimespec=st_mtim"
	+ libs="$libs -lutil"
	+ ;;
	+ "xDarwin")
	+ cflags="$cflags -DMSG_NOSIGNAL=SO_NOSIGPIPE -DLOGIN_NAME_MAX=MAXLOGNAME"
	+ if [ $terminfo -eq 0 ] ; then
	+ libs="-lncurses -lutil"
	+ else
	+ libs="-lutil"
	+ fi
	+ ;;
	+ "xFreeBSD")
	+ cflags="$cflags -D__dead=__dead2 -DLOGIN_NAME_MAX=MAXLOGNAME"
	+ libs="$libs -lutil"
	+ ;;
	+ "xOpenBSD")
	+ libs="$libs -lutil"
	+ ;;
	+ "xNetBSD")
	+ cflags="$cflags -D_OPENBSD_SOURCE"
	+ if [ $terminfo -eq 0 ] ; then
	+ libs="-lcurses -lutil"
	+ else
	+ libs="-lutil"
	+ fi
	+ ;;
	+ "xDragonFly")
	+ cflags="$cflags -D__dead=__dead2 -DLOGIN_NAME_MAX=MAXLOGNAME"
	+ libs="$libs -lutil"
	+ ;;
	+esac
	+
	+cat << EOF > config.h
	+/* This file generated automatically by configure. */
	+
	+#include "common.h"
	+#if defined(__linux__) \|\| defined(__CYGWIN__)
	+#include "linux.h"
	+#elif defined(__APPLE__)
	+#include "apple.h"
	+#elif defined(__FreeBSD__)
	+#include "freebsd.h"
	+#elif defined(__NetBSD__)
	+#include "netbsd.h"
	+#elif defined(__DragonFly__)
	+#include "dragonfly.h"
	+#endif
	+
	+EOF
	+
	+printf "checking for fparseln... "
	+fparselncheck
	+if [ $? -eq 0 ] ; then
	+ echo "#define HAVE_FPARSELN" >> config.h
	+ echo "yes"
	+else
	+ echo "extern char fparseln(FILE , size_t , size_t , const char[3], int);" >> config.h
	+ echo "no"
	+fi
	+
	+printf "checking for fstatat... "
	+fstatatcheck
	+if [ $? -eq 0 ] ; then
	+ echo "#define HAVE_FSTATAT" >> config.h
	+ echo "yes"
	+else
	+ echo "extern int fstatat(int, const char , struct stat , int);" >> config.h
	+ echo "no"
	+fi
	+
	+printf "checking for futimens... "
	+futimenscheck
	+if [ $? -eq 0 ] ; then
	+ echo "#define HAVE_FUTIMENS" >> config.h
	+ echo "yes"
	+else
	+ echo "extern int futimens(int, const struct timespec[2]);" >> config.h
	+ echo "no"
	+fi
	+
	+printf "checking for getline... "
	+getlinecheck
	+if [ $? -eq 0 ] ; then
	+ echo "#define HAVE_GETLINE" >> config.h
	+ echo "yes"
	+else
	+ echo "extern ssize_t getline(char *, size_t , FILE *);" >> config.h
	+ echo "no"
	+fi
	+
	+printf "checking for pledge... "
	+pledgecheck
	+if [ $? -eq 0 ] ; then
	+ echo "#define HAVE_PLEDGE" >> config.h
	+ echo "yes"
	+else
	+ echo "no"
	+fi
	+
	+printf "checking for reallocarray... "
	+reallocarraycheck
	+if [ $? -eq 0 ] ; then
	+ echo "#define HAVE_REALLOCARRAY" >> config.h
	+ echo "yes"
	+else
	+ echo "extern void reallocarray(void , size_t, size_t);" >> config.h
	+ echo "no"
	+fi
	+
	+printf "checking for strlcat... "
	+strlcatcheck
	+if [ $? -eq 0 ] ; then
	+ echo "#define HAVE_STRLCAT" >> config.h
	+ echo "yes"
	+else
	+ echo "extern size_t strlcat(char , const char , size_t);" >> config.h
	+ echo "no"
	+fi
	+
	+printf "checking for strlcpy... "
	+strlcpycheck
	+if [ $? -eq 0 ] ; then
	+ echo "#define HAVE_STRLCPY" >> config.h
	+ echo "yes"
	+else
	+ echo "extern size_t strlcpy(char , const char , size_t);" >> config.h
	+ echo "no"
	+fi
	+
	+printf "checking for strndup... "
	+strndupcheck
	+if [ $? -eq 0 ] ; then
	+ echo "#define HAVE_STRNDUP" >> config.h
	+ echo "yes"
	+else
	+ echo "extern char strndup(const char , size_t);" >> config.h
	+ echo "no"
	+fi
	+
	+printf "checking for strtonum... "
	+strtonumcheck
	+if [ $? -eq 0 ] ; then
	+ echo "#define HAVE_STRTONUM" >> config.h
	+ echo "yes"
	+else
	+ echo "extern long long strtonum(const char , long long, long long, const char *);" >> config.h
	+ echo "no"
	+fi
	+
	+printf "creating Makefile... "
	+cat << EOF > Makefile
	+# This Makefile automatically generated by configure.
	+.POSIX:
	+
	+CC = $cc
	+CFLAGS = $cflags
	+EOF
	+
	+if [ ! -z "$ldflags" ] ; then
	+cat << EOF >> Makefile
	+LDFLAGS = $ldflags
	+EOF
	+fi
	+
	+cat << EOF >> Makefile
	+PREFIX = $prefix
	+MANDIR = $mandir
	+
	+PROG = $prog
	+OBJS = autoexec.o basic.o bell.o buffer.o cinfo.o dir.o display.o \\
	+ echo.o extend.o file.o fileio.o funmap.o help.o kbd.o keymap.o \\
	+ line.o macro.o main.o match.o modes.o paragraph.o re_search.o \\
	+ region.o search.o spawn.o tty.o ttyio.o ttykbd.o undo.o util.o \\
	+ version.o window.o word.o yank.o cmode.o cscope.o dired.o \\
	+ grep.o tags.o fparseln.o fstatat.o futimens.o getline.o \\
	+ reallocarray.o strlcat.o strlcpy.o strndup.o strtonum.o \\
	+ interpreter.o extensions.o
	+
	+EOF
	+
	+if [ $terminfo -ne 0 ] ; then
	+cat << EOF >> Makefile
	+OBJS += term.o ti.o setupterm.o curterm.o tparm.o tputs.o \\
	+ compile.o hash.o termcap.o mi_vector_hash.o cdbr.o
	+
	+EOF
	+sed -i.bak 's,<term.h>,"terminfo_term.h",g' display.c echo.c spawn.c tty.c \
	+ ttyio.c ttykbd.c
	+else
	+sed -i.bak 's,"terminfo_term.h",<term.h>,g' display.c echo.c spawn.c tty.c \
	+ ttyio.c ttykbd.c
	+fi
	+
	+if [ $log -ne 0 ] ; then
	+cat << EOF >> Makefile
	+OBJS += log.o
	+
	+EOF
	+fi
	+
	+cat << EOF >> Makefile
	+all: \${PROG}
	+
	+\${PROG}: \${OBJS}
	+ \${CC} \${LDFLAGS} -o \${PROG} \${OBJS} $libs
	+
	+install:
	+ install -d \${DESTDIR}\${PREFIX}/bin
	+ install -d \${DESTDIR}\${MANDIR}/man1
	+ install -c -s -m 755 \${PROG} \${DESTDIR}\${PREFIX}/bin
	+ install -c -m 644 mg.1 \${DESTDIR}\${MANDIR}/man1/\${PROG}.1
	+
	+test:
	+ echo "No tests"
	+
	+clean:
	+ rm -f \${PROG} \${OBJS}
	+
	+distclean: clean
	+ rm -f Makefile config.h *.bak
	+EOF
	+echo "done"
	Index: contrib/mg/cscope.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/cscope.c
	@@ -0,0 +1,611 @@
	+/* $OpenBSD: cscope.c,v 1.20 2021/03/01 10:51:14 lum Exp $ */
	+
	+/*
	+ * This file is in the public domain.
	+ *
	+ * Author: Sunil Nimmagadda <sunil@openbsd.org>
	+ */
	+
	+#include <sys/queue.h>
	+#include <sys/stat.h>
	+#include <sys/types.h>
	+#include <ctype.h>
	+#include <errno.h>
	+#include <fcntl.h>
	+#include <fnmatch.h>
	+#include <limits.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+#include <unistd.h>
	+
	+#include "def.h"
	+
	+#define CSSYMBOL 0
	+#define CSDEFINITION 1
	+#define CSCALLEDFUNCS 2
	+#define CSCALLERFUNCS 3
	+#define CSTEXT 4
	+#define CSEGREP 6
	+#define CSFINDFILE 7
	+#define CSINCLUDES 8
	+
	+struct cstokens {
	+ const char *fname;
	+ const char *function;
	+ const char *lineno;
	+ const char *pattern;
	+};
	+
	+struct csmatch {
	+ TAILQ_ENTRY(csmatch) entry;
	+ int lineno;
	+};
	+
	+struct csrecord {
	+ TAILQ_ENTRY(csrecord) entry;
	+ char *filename;
	+ TAILQ_HEAD(matches, csmatch) matches;
	+};
	+
	+static TAILQ_HEAD(csrecords, csrecord) csrecords = TAILQ_HEAD_INITIALIZER(csrecords);
	+static struct csrecord *addentryr;
	+static struct csrecord *currecord;
	+static struct csmatch *curmatch;
	+static const char *addentryfn;
	+static const char *csprompt[] = {
	+ "Find this symbol: ",
	+ "Find this global definition: ",
	+ "Find functions called by this function: ",
	+ "Find functions calling this function: ",
	+ "Find this text string: ",
	+ "Change this text string: ",
	+ "Find this egrep pattern: ",
	+ "Find this file: ",
	+ "Find files #including this file: "
	+};
	+
	+static int addentry(struct buffer , char );
	+static void csflush(void);
	+static int do_cscope(int);
	+static int csexists(const char *);
	+static int getattr(char , struct cstokens );
	+static int jumptomatch(void);
	+static void prettyprint(struct buffer , struct cstokens );
	+static const char ltrim(const char );
	+
	+/*
	+ * Find this symbol. Bound to C-c s s
	+ */
	+/* ARGSUSED */
	+int
	+cssymbol(int f, int n)
	+{
	+ return (do_cscope(CSSYMBOL));
	+}
	+
	+/*
	+ * Find this global definition. Bound to C-c s d
	+ */
	+/* ARGSUSED */int
	+csdefinition(int f, int n)
	+{
	+ return (do_cscope(CSDEFINITION));
	+}
	+
	+/*
	+ * Find functions called by this function. Bound to C-c s l
	+ */
	+/* ARGSUSED */
	+int
	+csfuncalled(int f, int n)
	+{
	+ return (do_cscope(CSCALLEDFUNCS));
	+}
	+
	+/*
	+ * Find functions calling this function. Bound to C-c s c
	+ */
	+/* ARGSUSED */
	+int
	+cscallerfuncs(int f, int n)
	+{
	+ return (do_cscope(CSCALLERFUNCS));
	+}
	+
	+/*
	+ * Find this text. Bound to C-c s t
	+ */
	+/* ARGSUSED */
	+int
	+csfindtext(int f, int n)
	+{
	+ return (do_cscope(CSTEXT));
	+}
	+
	+/*
	+ * Find this egrep pattern. Bound to C-c s e
	+ */
	+/* ARGSUSED */
	+int
	+csegrep(int f, int n)
	+{
	+ return (do_cscope(CSEGREP));
	+}
	+
	+/*
	+ * Find this file. Bound to C-c s f
	+ */
	+/* ARGSUSED */
	+int
	+csfindfile(int f, int n)
	+{
	+ return (do_cscope(CSFINDFILE));
	+}
	+
	+/*
	+ * Find files #including this file. Bound to C-c s i
	+ */
	+/* ARGSUSED */
	+int
	+csfindinc(int f, int n)
	+{
	+ return (do_cscope(CSINCLUDES));
	+}
	+
	+/*
	+ * Create list of files to index in the given directory
	+ * using cscope-indexer.
	+ */
	+/* ARGSUSED */
	+int
	+cscreatelist(int f, int n)
	+{
	+ struct buffer *bp;
	+ struct stat sb;
	+ FILE *fpipe;
	+ char dir[NFILEN], cmd[BUFSIZ], title[BUFSIZ], line, bufp;
	+ size_t sz;
	+ ssize_t len;
	+ int clen;
	+
	+ line = NULL;
	+ sz = 0;
	+
	+ if (getbufcwd(dir, sizeof(dir)) == FALSE)
	+ dir[0] = '\0';
	+
	+ bufp = eread("Index files in directory: ", dir,
	+ sizeof(dir), EFCR \| EFDEF \| EFNEW \| EFNUL);
	+
	+ if (bufp == NULL)
	+ return (ABORT);
	+ else if (bufp[0] == '\0')
	+ return (FALSE);
	+
	+ if (stat(dir, &sb) == -1)
	+ return(dobeep_msgs("stat: %s", strerror(errno)));
	+ else if (S_ISDIR(sb.st_mode) == 0)
	+ return(dobeep_msgs("%s: Not a directory", dir));
	+
	+ if (csexists("cscope-indexer") == FALSE)
	+ return(dobeep_msg("no such file or directory, cscope-indexer"));
	+
	+ clen = snprintf(cmd, sizeof(cmd), "cscope-indexer -v %s", dir);
	+ if (clen < 0 \|\| clen >= sizeof(cmd))
	+ return (FALSE);
	+
	+ if ((fpipe = popen(cmd, "r")) == NULL)
	+ return(dobeep_msg("problem opening pipe"));
	+
	+ bp = bfind("cscope", TRUE);
	+ if (bclear(bp) != TRUE) {
	+ pclose(fpipe);
	+ return (FALSE);
	+ }
	+ bp->b_flag \|= BFREADONLY;
	+
	+ clen = snprintf(title, sizeof(title), "%s%s",
	+ "Creating cscope file list 'cscope.files' in: ", dir);
	+ if (clen < 0 \|\| clen >= sizeof(title)) {
	+ pclose(fpipe);
	+ return (FALSE);
	+ }
	+ addline(bp, title);
	+ addline(bp, "");
	+ while ((len = getline(&line, &sz, fpipe)) != -1) {
	+ if (line[len - 1] == *bp->b_nlchr)
	+ line[len - 1] = '\0';
	+ addline(bp, line);
	+ }
	+ free(line);
	+ if (ferror(fpipe))
	+ ewprintf("Problem reading pipe");
	+ pclose(fpipe);
	+ return (popbuftop(bp, WNONE));
	+}
	+
	+/*
	+ * Next Symbol. Bound to C-c s n
	+ */
	+/* ARGSUSED */
	+int
	+csnextmatch(int f, int n)
	+{
	+ struct csrecord *r;
	+ struct csmatch *m;
	+
	+ if (curmatch == NULL) {
	+ if ((r = TAILQ_FIRST(&csrecords)) == NULL)
	+ return(dobeep_msg("The cscope buffer does "
	+ "not exist yet"));
	+
	+ currecord = r;
	+ curmatch = TAILQ_FIRST(&r->matches);
	+ } else {
	+ m = TAILQ_NEXT(curmatch, entry);
	+ if (m == NULL) {
	+ r = TAILQ_NEXT(currecord, entry);
	+ if (r == NULL) {
	+ return(dobeep_msg("The end of cscope buffer "
	+ "has been reached"));
	+ } else {
	+ currecord = r;
	+ curmatch = TAILQ_FIRST(&currecord->matches);
	+ }
	+ } else
	+ curmatch = m;
	+ }
	+ return (jumptomatch());
	+}
	+
	+/*
	+ * Previous Symbol. Bound to C-c s p
	+ */
	+/* ARGSUSED */
	+int
	+csprevmatch(int f, int n)
	+{
	+ struct csmatch *m;
	+ struct csrecord *r;
	+
	+ if (curmatch == NULL)
	+ return (FALSE);
	+ else {
	+ m = TAILQ_PREV(curmatch, matches, entry);
	+ if (m)
	+ curmatch = m;
	+ else {
	+ r = TAILQ_PREV(currecord, csrecords, entry);
	+ if (r == NULL) {
	+ return(dobeep_msg("The beginning of cscope "
	+ "buffer has been reached"));
	+ } else {
	+ currecord = r;
	+ curmatch = TAILQ_LAST(&currecord->matches,
	+ matches);
	+ }
	+ }
	+ }
	+ return (jumptomatch());
	+}
	+
	+/*
	+ * Next file.
	+ */
	+int
	+csnextfile(int f, int n)
	+{
	+ struct csrecord *r;
	+
	+ if (curmatch == NULL) {
	+ if ((r = TAILQ_FIRST(&csrecords)) == NULL)
	+ return(dobeep_msg("The cscope buffer does not "
	+ "exist yet"));
	+ } else {
	+ if ((r = TAILQ_NEXT(currecord, entry)) == NULL)
	+ return(dobeep_msg("The end of cscope buffer has "
	+ "been reached"));
	+ }
	+ currecord = r;
	+ curmatch = TAILQ_FIRST(&currecord->matches);
	+ return (jumptomatch());
	+}
	+
	+/*
	+ * Previous file.
	+ */
	+int
	+csprevfile(int f, int n)
	+{
	+ struct csrecord *r;
	+
	+ if (curmatch == NULL) {
	+ if ((r = TAILQ_FIRST(&csrecords)) == NULL)
	+ return(dobeep_msg("The cscope buffer does not"
	+ "exist yet"));
	+ } else {
	+ if ((r = TAILQ_PREV(currecord, csrecords, entry)) == NULL)
	+ return(dobeep_msg("The beginning of cscope buffer "
	+ "has been reached"));
	+ }
	+ currecord = r;
	+ curmatch = TAILQ_FIRST(&currecord->matches);
	+ return (jumptomatch());
	+}
	+
	+/*
	+ * The current symbol location is extracted from currecord->filename and
	+ * curmatch->lineno. Load the file similar to filevisit and goto the
	+ * lineno recorded.
	+ */
	+int
	+jumptomatch(void)
	+{
	+ struct buffer *bp;
	+ char *adjf;
	+
	+ if (curmatch == NULL \|\| currecord == NULL)
	+ return (FALSE);
	+ adjf = adjustname(currecord->filename, TRUE);
	+ if (adjf == NULL)
	+ return (FALSE);
	+ if ((bp = findbuffer(adjf)) == NULL)
	+ return (FALSE);
	+ curbp = bp;
	+ if (showbuffer(bp, curwp, WFFULL) != TRUE)
	+ return (FALSE);
	+ if (bp->b_fname[0] == '\0') {
	+ if (readin(adjf) != TRUE)
	+ killbuffer(bp);
	+ }
	+ gotoline(FFARG, curmatch->lineno);
	+ return (TRUE);
	+}
	+
	+/*
	+ * Ask for the symbol, construct cscope commandline with the symbol
	+ * and passed in index. Popen cscope, read the output into cscope
	+ * buffer and pop it.
	+ */
	+int
	+do_cscope(int i)
	+{
	+ struct buffer *bp;
	+ FILE *fpipe;
	+ char pattern[MAX_TOKEN], cmd[BUFSIZ], title[BUFSIZ];
	+ char p, buf;
	+ int clen, nores = 0;
	+ size_t sz;
	+ ssize_t len;
	+
	+ buf = NULL;
	+ sz = 0;
	+
	+ /* If current buffer isn't a source file just return */
	+ if (fnmatch("*.[chy]", curbp->b_fname, 0) != 0)
	+ return(dobeep_msg("C-c s not defined"));
	+
	+ if (curtoken(0, 1, pattern) == FALSE)
	+ return (FALSE);
	+ p = eread("%s", pattern, MAX_TOKEN, EFNEW \| EFCR \| EFDEF, csprompt[i]);
	+ if (p == NULL)
	+ return (ABORT);
	+ else if (p[0] == '\0')
	+ return (FALSE);
	+
	+ if (csexists("cscope") == FALSE)
	+ return(dobeep_msg("no such file or directory, cscope"));
	+
	+ csflush();
	+ clen = snprintf(cmd, sizeof(cmd), "cscope -L -%d %s 2>/dev/null",
	+ i, pattern);
	+ if (clen < 0 \|\| clen >= sizeof(cmd))
	+ return (FALSE);
	+
	+ if ((fpipe = popen(cmd, "r")) == NULL)
	+ return(dobeep_msg("problem opening pipe"));
	+
	+ bp = bfind("cscope", TRUE);
	+ if (bclear(bp) != TRUE) {
	+ pclose(fpipe);
	+ return (FALSE);
	+ }
	+ bp->b_flag \|= BFREADONLY;
	+
	+ clen = snprintf(title, sizeof(title), "%s%s", csprompt[i], pattern);
	+ if (clen < 0 \|\| clen >= sizeof(title)) {
	+ pclose(fpipe);
	+ return (FALSE);
	+ }
	+ addline(bp, title);
	+ addline(bp, "");
	+ addline(bp, "-------------------------------------------------------------------------------");
	+ while ((len = getline(&buf, &sz, fpipe)) != -1) {
	+ if (buf[len - 1] == *bp->b_nlchr)
	+ buf[len - 1] = '\0';
	+ if (addentry(bp, buf) != TRUE) {
	+ free(buf);
	+ return (FALSE);
	+ }
	+ nores = 1;
	+ }
	+ free(buf);
	+ if (ferror(fpipe))
	+ ewprintf("Problem reading pipe");
	+ pclose(fpipe);
	+ addline(bp, "-------------------------------------------------------------------------------");
	+ if (nores == 0)
	+ ewprintf("No matches were found.");
	+ return (popbuftop(bp, WNONE));
	+}
	+
	+/*
	+ * For each line read from cscope output, extract the tokens,
	+ * add them to list and pretty print a line in cscope buffer.
	+ */
	+int
	+addentry(struct buffer bp, char csline)
	+{
	+ struct csrecord *r;
	+ struct csmatch *m;
	+ struct cstokens t;
	+ int lineno;
	+ char buf[BUFSIZ];
	+ const char *errstr;
	+
	+ r = NULL;
	+ if (getattr(csline, &t) == FALSE)
	+ return (FALSE);
	+
	+ lineno = strtonum(t.lineno, INT_MIN, INT_MAX, &errstr);
	+ if (errstr)
	+ return (FALSE);
	+
	+ if (addentryfn == NULL \|\| strcmp(addentryfn, t.fname) != 0) {
	+ if ((r = malloc(sizeof(struct csrecord))) == NULL)
	+ return (FALSE);
	+ addentryr = r;
	+ if ((r->filename = strndup(t.fname, NFILEN)) == NULL)
	+ goto cleanup;
	+ addentryfn = r->filename;
	+ TAILQ_INIT(&r->matches);
	+ if ((m = malloc(sizeof(struct csmatch))) == NULL)
	+ goto cleanup;
	+ m->lineno = lineno;
	+ TAILQ_INSERT_TAIL(&r->matches, m, entry);
	+ TAILQ_INSERT_TAIL(&csrecords, r, entry);
	+ addline(bp, "");
	+ if (snprintf(buf, sizeof(buf), "*** %s", t.fname) < 0)
	+ goto cleanup;
	+ addline(bp, buf);
	+ } else {
	+ if ((m = malloc(sizeof(struct csmatch))) == NULL)
	+ goto cleanup;
	+ m->lineno = lineno;
	+ TAILQ_INSERT_TAIL(&addentryr->matches, m, entry);
	+ }
	+ prettyprint(bp, &t);
	+ return (TRUE);
	+cleanup:
	+ free(r);
	+ return (FALSE);
	+}
	+
	+/*
	+ * Cscope line: <filename> <function> <lineno> <pattern>
	+ */
	+int
	+getattr(char line, struct cstokens t)
	+{
	+ char *p;
	+
	+ if ((p = strchr(line, ' ')) == NULL)
	+ return (FALSE);
	+ *p++ = '\0';
	+ t->fname = line;
	+ line = p;
	+
	+ if ((p = strchr(line, ' ')) == NULL)
	+ return (FALSE);
	+ *p++ = '\0';
	+ t->function = line;
	+ line = p;
	+
	+ if ((p = strchr(line, ' ')) == NULL)
	+ return (FALSE);
	+ *p++ = '\0';
	+ t->lineno = line;
	+
	+ if (*p == '\0')
	+ return (FALSE);
	+ t->pattern = p;
	+
	+ return (TRUE);
	+}
	+
	+void
	+prettyprint(struct buffer bp, struct cstokens t)
	+{
	+ char buf[BUFSIZ];
	+
	+ if (snprintf(buf, sizeof(buf), "%s[%s]\t\t%s",
	+ t->function, t->lineno, ltrim(t->pattern)) < 0)
	+ return;
	+ addline(bp, buf);
	+}
	+
	+const char *
	+ltrim(const char *s)
	+{
	+ while (isblank((unsigned char)*s))
	+ s++;
	+ return s;
	+}
	+
	+void
	+csflush(void)
	+{
	+ struct csrecord *r;
	+ struct csmatch *m;
	+
	+ while ((r = TAILQ_FIRST(&csrecords)) != NULL) {
	+ free(r->filename);
	+ while ((m = TAILQ_FIRST(&r->matches)) != NULL) {
	+ TAILQ_REMOVE(&r->matches, m, entry);
	+ free(m);
	+ }
	+ TAILQ_REMOVE(&csrecords, r, entry);
	+ free(r);
	+ }
	+ addentryr = NULL;
	+ addentryfn = NULL;
	+ currecord = NULL;
	+ curmatch = NULL;
	+}
	+
	+/*
	+ * Check if the cmd exists in $PATH. Split on ":" and iterate through
	+ * all paths in $PATH.
	+ */
	+int
	+csexists(const char *cmd)
	+{
	+ char fname[NFILEN], dir, path, pathc, tmp;
	+ int len, dlen;
	+
	+ /* Special case if prog contains '/' */
	+ if (strchr(cmd, '/')) {
	+ if (access(cmd, F_OK) == -1)
	+ return (FALSE);
	+ else
	+ return (TRUE);
	+ }
	+ if ((tmp = getenv("PATH")) == NULL)
	+ return (FALSE);
	+ if ((pathc = path = strndup(tmp, NFILEN)) == NULL)
	+ return(dobeep_msg("out of memory"));
	+
	+ while ((dir = strsep(&path, ":")) != NULL) {
	+ if (*dir == '\0')
	+ continue;
	+
	+ dlen = strlen(dir);
	+ while (dlen > 0 && dir[dlen-1] == '/')
	+ dir[--dlen] = '\0'; /* strip trailing '/' */
	+
	+ len = snprintf(fname, sizeof(fname), "%s/%s", dir, cmd);
	+ if (len < 0 \|\| len >= sizeof(fname)) {
	+ (void)dobeep_msg("path too long");
	+ goto cleanup;
	+ }
	+ if(access(fname, F_OK) == 0) {
	+ free(pathc);
	+ return (TRUE);
	+ }
	+ }
	+cleanup:
	+ free(pathc);
	+ return (FALSE);
	+}
	Index: contrib/mg/curterm.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/curterm.c
	@@ -0,0 +1,170 @@
	+/* $NetBSD: curterm.c,v 1.13 2017/05/04 09:42:23 roy Exp $ */
	+
	+/*
	+ * Copyright (c) 2009, 2011 The NetBSD Foundation, Inc.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Roy Marples.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ */
	+
	+#include <sys/cdefs.h>
	+
	+#include <stdlib.h>
	+#include <string.h>
	+#include <termios.h>
	+#include <stdio.h>
	+
	+#include "term_private.h"
	+#include "terminfo_term.h"
	+
	+#ifndef __arraycount
	+#define __arraycount(__x) (sizeof(__x) / sizeof(__x[0]))
	+#endif
	+
	+#ifndef __UNCONST
	+#define __UNCONST(a) ((void )(unsigned long)(const void )(a))
	+#endif
	+
	+TERMINAL *cur_term;
	+
	+/*
	+ * There is no standard way of getting a list of aliases for the
	+ * terminal. However, some applications such as telnet want to know this.
	+ * ncurses dumps the terminfo header into an undefined variable ttytype
	+ * and these applications then parse it to work out the aliases.
	+ * We should do the same for now, until a standard mechanism for getting
	+ * the information is available or the need for it goes away.
	+ */
	+#define NAMESIZE 256
	+char ttytype[NAMESIZE];
	+
	+static const speed_t bauds[] = {
	+ 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 2400, 4800, 9600,
	+ 19200, 38400, 57600, 115200, 230400, 460800, 921600
	+};
	+
	+void
	+_ti_setospeed(TERMINAL *term)
	+{
	+ struct termios termios;
	+ speed_t os;
	+ size_t i;
	+
	+ term->_ospeed = 0;
	+ if (tcgetattr(term->fildes, &termios) == 0) {
	+ os = cfgetospeed(&termios);
	+ for (i = 0; i < __arraycount(bauds); i++)
	+ if (bauds[i] == os) {
	+ term->_ospeed = (short)i;
	+ break;
	+ }
	+ }
	+}
	+
	+TERMINAL *
	+set_curterm(TERMINAL *nterm)
	+{
	+ TERMINAL *oterm;
	+ size_t l, n;
	+ char *p;
	+
	+ oterm = cur_term;
	+ cur_term = nterm;
	+
	+ ospeed = 0;
	+ if (cur_term == NULL)
	+ PC = '\0';
	+ else {
	+ if (pad_char == NULL)
	+ PC = '\0';
	+ else
	+ PC = *pad_char;
	+ _ti_setospeed(nterm);
	+ ospeed = nterm->_ospeed;
	+
	+ p = ttytype;
	+ l = sizeof(ttytype);
	+ if ((n = strlcpy(p, nterm->name, l)) == strlen(p)) {
	+ p += n;
	+ l -= n;
	+ *p++ = '\|';
	+ l--;
	+ if (nterm->_alias &&
	+ (n = strlcpy(p, nterm->_alias, l)) == strlen(p))
	+ {
	+ p += n;
	+ l -= n;
	+ *p++ = '\|';
	+ l--;
	+ }
	+ if (nterm->desc &&
	+ (n = strlcpy(p, nterm->desc, l)) == strlen(p))
	+ {
	+ p += n;
	+ l -= n;
	+ *p++ = '\|';
	+ l--;
	+ }
	+ p--;
	+ }
	+ *p = '\0';
	+ }
	+
	+ return oterm;
	+}
	+
	+int
	+del_curterm(TERMINAL *oterm)
	+{
	+
	+ if (oterm == NULL)
	+ return ERR;
	+ free(oterm->_area);
	+ free(oterm->strs);
	+ free(oterm->nums);
	+ free(oterm->flags);
	+ free(oterm->_userdefs);
	+ free(oterm->_buf);
	+ free(oterm);
	+ if (oterm == cur_term)
	+ cur_term = NULL;
	+ return OK;
	+}
	+
	+char *
	+termname(void)
	+{
	+
	+ return __UNCONST(cur_term->name);
	+}
	+
	+static const char * nullname = "";
	+
	+char *
	+longname(void)
	+{
	+
	+ if (cur_term->desc == NULL)
	+ return __UNCONST(nullname);
	+ return __UNCONST(cur_term->desc);
	+}
	Index: contrib/mg/def.h
	===================================================================
	--- /dev/null
	+++ contrib/mg/def.h
	@@ -0,0 +1,788 @@
	+/* $OpenBSD: def.h,v 1.176 2021/05/06 14:16:12 lum Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * This file is the general header file for all parts
	+ * of the Mg display editor. It contains all of the
	+ * general definitions and macros. It also contains some
	+ * conditional compilation flags. All of the per-system and
	+ * per-terminal definitions are in special header files.
	+ */
	+
	+/*
	+ * We open with Mg portable things.
	+ */
	+#include "config.h"
	+
	+#include "chrdef.h"
	+
	+typedef int (PF)(int, int); / generally useful type */
	+
	+/*
	+ * Table sizes, etc.
	+ */
	+#define NFILEN 1024 /* Length, file name. */
	+#define NBUFN NFILEN /* Length, buffer name. */
	+#define NLINE 256 /* Length, line. */
	+#define PBMODES 4 /* modes per buffer */
	+#define NPAT 80 /* Length, pattern. */
	+#define HUGE 1000 /* A rather large number. */
	+#define NSRCH 128 /* Undoable search commands. */
	+#define NXNAME 64 /* Length, extended command. */
	+#define NKNAME 20 /* Length, key names. */
	+#define NTIME 50 /* Length, timestamp string. */
	+
	+/*
	+ * Universal.
	+ */
	+#define FALSE 0 /* False, no, bad, etc. */
	+#define TRUE 1 /* True, yes, good, etc. */
	+#define ABORT 2 /* Death, ^G, abort, etc. */
	+#define UERROR 3 /* User Error. */
	+#define REVERT 4 /* Revert the buffer */
	+
	+#define KCLEAR 2 /* clear echo area */
	+
	+/*
	+ * These flag bits keep track of
	+ * some aspects of the last command. The CFCPCN
	+ * flag controls goal column setting. The CFKILL
	+ * flag controls the clearing versus appending
	+ * of data in the kill buffer.
	+ */
	+#define CFCPCN 0x0001 /* Last command was C-p or C-n */
	+#define CFKILL 0x0002 /* Last command was a kill */
	+#define CFINS 0x0004 /* Last command was self-insert */
	+
	+/*
	+ * File I/O.
	+ */
	+#define FIOSUC 0 /* Success. */
	+#define FIOFNF 1 /* File not found. */
	+#define FIOEOF 2 /* End of file. */
	+#define FIOERR 3 /* Error. */
	+#define FIOLONG 4 /* long line partially read */
	+#define FIODIR 5 /* File is a directory */
	+
	+/*
	+ * Display colors.
	+ */
	+#define CNONE 0 /* Unknown color. */
	+#define CTEXT 1 /* Text color. */
	+#define CMODE 2 /* Mode line color. */
	+
	+/*
	+ * Flags for keyboard invoked functions.
	+ */
	+#define FFUNIV 1 /* universal argument */
	+#define FFNEGARG 2 /* negative only argument */
	+#define FFOTHARG 4 /* other argument */
	+#define FFARG 7 /* any argument */
	+#define FFRAND 8 /* Called by other function */
	+
	+/*
	+ * Flags for "eread".
	+ */
	+#define EFFUNC 0x0001 /* Autocomplete functions. */
	+#define EFBUF 0x0002 /* Autocomplete buffers. */
	+#define EFFILE 0x0004 /* " files (maybe someday) */
	+#define EFAUTO 0x0007 /* Some autocompletion on */
	+#define EFNEW 0x0008 /* New prompt. */
	+#define EFCR 0x0010 /* Echo CR at end; last read. */
	+#define EFDEF 0x0020 /* buffer contains default args */
	+#define EFNUL 0x0040 /* Null Minibuffer OK */
	+
	+/*
	+ * Direction of insert into kill ring
	+ */
	+#define KNONE 0x00
	+#define KFORW 0x01 /* forward insert into kill ring */
	+#define KBACK 0x02 /* Backwards insert into kill ring */
	+#define KREG 0x04 /* This is a region-based kill */
	+
	+#define MAX_TOKEN 64
	+
	+#define BUFSIZE 128 /* Size of line contents in extend.c */
	+/*
	+ * Previously from sysdef.h
	+ */
	+typedef int RSIZE; /* Type for file/region sizes */
	+typedef short KCHAR; /* Type for internal keystrokes */
	+
	+/*
	+ * This structure holds the starting position
	+ * (as a line/offset pair) and the number of characters in a
	+ * region of a buffer. This makes passing the specification
	+ * of a region around a little bit easier.
	+ */
	+struct region {
	+ struct line r_linep; / Origin line address. */
	+ int r_offset; /* Origin line offset. */
	+ int r_lineno; /* Origin line number */
	+ RSIZE r_size; /* Length in characters. */
	+};
	+
	+
	+/*
	+ * All text is kept in circularly linked
	+ * lists of "line" structures. These begin at the
	+ * header line (which is the blank line beyond the
	+ * end of the buffer). This line is pointed to by
	+ * the "buffer" structure. Each line contains the number of
	+ * bytes in the line (the "used" size), the size
	+ * of the text array, and the text. The end of line
	+ * is not stored as a byte; it's implied. Future
	+ * additions will include update hints, and a
	+ * list of marks into the line.
	+ */
	+struct line {
	+ struct line l_fp; / Link to the next line */
	+ struct line l_bp; / Link to the previous line */
	+ int l_size; /* Allocated size */
	+ int l_used; /* Used size */
	+ char l_text; / Content of the line */
	+};
	+
	+/*
	+ * The rationale behind these macros is that you
	+ * could (with some editing, like changing the type of a line
	+ * link from a "struct line *" to a "REFLINE", and fixing the commands
	+ * like file reading that break the rules) change the actual
	+ * storage representation of lines to use something fancy on
	+ * machines with small address spaces.
	+ */
	+#define lforw(lp) ((lp)->l_fp)
	+#define lback(lp) ((lp)->l_bp)
	+#define lgetc(lp, n) (CHARMASK((lp)->l_text[(n)]))
	+#define lputc(lp, n, c) ((lp)->l_text[(n)]=(c))
	+#define llength(lp) ((lp)->l_used)
	+#define ltext(lp) ((lp)->l_text)
	+
	+/*
	+ * All repeated structures are kept as linked lists of structures.
	+ * All of these start with a LIST structure (except lines, which
	+ * have their own abstraction). This will allow for
	+ * later conversion to generic list manipulation routines should
	+ * I decide to do that. It does mean that there are four extra
	+ * bytes per window. I feel that this is an acceptable price,
	+ * considering that there are usually only one or two windows.
	+ */
	+struct list {
	+ union {
	+ struct mgwin *l_wp;
	+ struct buffer x_bp; / l_bp is used by struct line */
	+ struct list *l_nxt;
	+ } l_p;
	+ char *l_name;
	+};
	+
	+/*
	+ * Usual hack - to keep from uglifying the code with lotsa
	+ * references through the union, we #define something for it.
	+ */
	+#define l_next l_p.l_nxt
	+
	+/*
	+ * There is a window structure allocated for
	+ * every active display window. The windows are kept in a
	+ * big list, in top to bottom screen order, with the listhead at
	+ * "wheadp". Each window contains its own values of dot and mark.
	+ * The flag field contains some bits that are set by commands
	+ * to guide redisplay; although this is a bit of a compromise in
	+ * terms of decoupling, the full blown redisplay is just too
	+ * expensive to run for every input character.
	+ */
	+struct mgwin {
	+ struct list w_list; /* List header */
	+ struct buffer w_bufp; / Buffer displayed in window */
	+ struct line w_linep; / Top line in the window */
	+ struct line w_dotp; / Line containing "." */
	+ struct line w_markp; / Line containing "mark" */
	+ int w_doto; /* Byte offset for "." */
	+ int w_marko; /* Byte offset for "mark" */
	+ int w_toprow; /* Origin 0 top row of window */
	+ int w_ntrows; /* # of rows of text in window */
	+ int w_frame; /* #lines to reframe by. */
	+ char w_rflag; /* Redisplay Flags. */
	+ char w_flag; /* Flags. */
	+ struct line *w_wrapline;
	+ int w_dotline; /* current line number of dot */
	+ int w_markline; /* current line number of mark */
	+};
	+#define w_wndp w_list.l_p.l_wp
	+#define w_name w_list.l_name
	+
	+/*
	+ * Window redisplay flags are set by command processors to
	+ * tell the display system what has happened to the buffer
	+ * mapped by the window. Setting "WFFULL" is always a safe thing
	+ * to do, but it may do more work than is necessary. Always try
	+ * to set the simplest action that achieves the required update.
	+ * Because commands set bits in the "w_flag", update will see
	+ * all change flags, and do the most general one.
	+ */
	+#define WFFRAME 0x01 /* Force reframe. */
	+#define WFMOVE 0x02 /* Movement from line to line. */
	+#define WFEDIT 0x04 /* Editing within a line. */
	+#define WFFULL 0x08 /* Do a full display. */
	+#define WFMODE 0x10 /* Update mode line. */
	+
	+/*
	+ * Window flags
	+ */
	+#define WNONE 0x00 /* No special window options. */
	+#define WEPHEM 0x01 /* Window is ephemeral. */
	+
	+struct undo_rec;
	+TAILQ_HEAD(undoq, undo_rec);
	+
	+/*
	+ * Previously from sysdef.h
	+ * Only used in struct buffer.
	+ */
	+struct fileinfo {
	+ uid_t fi_uid;
	+ gid_t fi_gid;
	+ mode_t fi_mode;
	+ struct timespec fi_mtime; /* Last modified time */
	+};
	+
	+/*
	+ * Text is kept in buffers. A buffer header, described
	+ * below, exists for every buffer in the system. The buffers are
	+ * kept in a big list, so that commands that search for a buffer by
	+ * name can find the buffer header. There is a safe store for the
	+ * dot and mark in the header, but this is only valid if the buffer
	+ * is not being displayed (that is, if "b_nwnd" is 0). The text for
	+ * the buffer is kept in a circularly linked list of lines, with
	+ * a pointer to the header line in "b_headp".
	+ */
	+struct buffer {
	+ struct list b_list; /* buffer list pointer */
	+ struct buffer b_altb; / Link to alternate buffer */
	+ struct line b_dotp; / Link to "." line structure */
	+ struct line b_markp; / ditto for mark */
	+ struct line b_headp; / Link to the header line */
	+ struct maps_s b_modes[PBMODES]; / buffer modes */
	+ int b_doto; /* Offset of "." in above line */
	+ int b_marko; /* ditto for the "mark" */
	+ short b_nmodes; /* number of non-fundamental modes */
	+ char b_nwnd; /* Count of windows on buffer */
	+ char b_flag; /* Flags */
	+ char b_fname[NFILEN]; /* File name */
	+ char b_cwd[NFILEN]; /* working directory */
	+ char b_nlseq; / Newline sequence of chars */
	+ char b_nlchr; / 1st newline character */
	+ struct fileinfo b_fi; /* File attributes */
	+ struct undoq b_undo; /* Undo actions list */
	+ struct undo_rec *b_undoptr;
	+ int b_dotline; /* Line number of dot */
	+ int b_markline; /* Line number of mark */
	+ int b_lines; /* Number of lines in file */
	+};
	+#define b_bufp b_list.l_p.x_bp
	+#define b_bname b_list.l_name
	+
	+/* Some helper macros, in case they ever change to functions */
	+#define bfirstlp(buf) (lforw((buf)->b_headp))
	+#define blastlp(buf) (lback((buf)->b_headp))
	+
	+#define BFCHG 0x01 /* Changed. */
	+#define BFBAK 0x02 /* Need to make a backup. */
	+#ifdef NOTAB
	+#define BFNOTAB 0x04 /* no tab mode */
	+#endif
	+#define BFOVERWRITE 0x08 /* overwrite mode */
	+#define BFREADONLY 0x10 /* read only mode */
	+#define BFDIRTY 0x20 /* Buffer was modified elsewhere */
	+#define BFIGNDIRTY 0x40 /* Ignore modifications */
	+#define BFDIREDDEL 0x80 /* Dired has a deleted 'D' file */
	+/*
	+ * This structure holds information about recent actions for the Undo command.
	+ */
	+struct undo_rec {
	+ TAILQ_ENTRY(undo_rec) next;
	+ enum {
	+ INSERT = 1,
	+ DELETE,
	+ BOUNDARY,
	+ MODIFIED,
	+ DELREG
	+ } type;
	+ struct region region;
	+ int pos;
	+ char *content;
	+};
	+
	+/*
	+ * Variable structure.
	+ */
	+struct varentry {
	+ SLIST_ENTRY(varentry) entry;
	+ char v_buf[BUFSIZE];
	+ char *v_name;
	+ char *v_vals;
	+ int v_count;
	+};
	+SLIST_HEAD(vhead, varentry);
	+
	+/*
	+ * Previously from ttydef.h
	+ */
	+#define STANDOUT_GLITCH /* possible standout glitch */
	+
	+#define putpad(str, num) tputs(str, num, ttputc)
	+
	+#define KFIRST K00
	+#define KLAST K00
	+
	+/*
	+ * Prototypes.
	+ */
	+
	+/* tty.c X */
	+void ttinit(void);
	+void ttreinit(void);
	+void tttidy(void);
	+void ttmove(int, int);
	+void tteeol(void);
	+void tteeop(void);
	+void ttbeep(void);
	+void ttinsl(int, int, int);
	+void ttdell(int, int, int);
	+void ttwindow(int, int);
	+void ttnowindow(void);
	+void ttcolor(int);
	+void ttresize(void);
	+
	+extern volatile sig_atomic_t winch_flag;
	+
	+/* ttyio.c */
	+void ttopen(void);
	+int ttraw(void);
	+void ttclose(void);
	+int ttcooked(void);
	+int ttputc(int);
	+void ttflush(void);
	+int ttgetc(void);
	+int ttwait(int);
	+int charswaiting(void);
	+
	+/* dir.c */
	+void dirinit(void);
	+int changedir(int, int);
	+int showcwdir(int, int);
	+int getcwdir(char *, size_t);
	+int makedir(int, int);
	+int do_makedir(char *);
	+int ask_makedir(void);
	+
	+/* dired.c */
	+struct buffer dired_(char );
	+int dired_jump(int, int);
	+int do_dired(char *);
	+
	+/* file.c X */
	+int fileinsert(int, int);
	+int filevisit(int, int);
	+int filevisitalt(int, int);
	+int filevisitro(int, int);
	+int poptofile(int, int);
	+int readin(char *);
	+int insertfile(char , char , int);
	+int filewrite(int, int);
	+int filesave(int, int);
	+int buffsave(struct buffer *);
	+int makebkfile(int, int);
	+int writeout(FILE *, struct buffer , char *);
	+void upmodes(struct buffer *);
	+size_t xbasename(char , const char , size_t);
	+int do_filevisitalt(char *);
	+
	+/* line.c X */
	+struct line *lalloc(int);
	+int lrealloc(struct line *, int);
	+void lfree(struct line *);
	+void lchange(int);
	+int linsert(int, int);
	+int lnewline_at(struct line *, int);
	+int lnewline(void);
	+int ldelete(RSIZE, int);
	+int ldelnewline(void);
	+int lreplace(RSIZE, char *);
	+char * linetostr(const struct line *);
	+int setcasereplace(int, int);
	+
	+/* yank.c X */
	+
	+void kdelete(void);
	+int kinsert(int, int);
	+int kremove(int);
	+int kchunk(char *, RSIZE, int);
	+int killline(int, int);
	+int yank(int, int);
	+
	+/* window.c X */
	+struct mgwin new_window(struct buffer );
	+int reposition(int, int);
	+int redraw(int, int);
	+int do_redraw(int, int, int);
	+int nextwind(int, int);
	+int prevwind(int, int);
	+int onlywind(int, int);
	+int splitwind(int, int);
	+int enlargewind(int, int);
	+int shrinkwind(int, int);
	+int delwind(int, int);
	+
	+/* buffer.c */
	+int togglereadonly(int, int);
	+int togglereadonlyall(int, int);
	+struct buffer bfind(const char , int);
	+int poptobuffer(int, int);
	+int killbuffer(struct buffer *);
	+int killbuffer_cmd(int, int);
	+int savebuffers(int, int);
	+int listbuffers(int, int);
	+int addlinef(struct buffer , char , ...);
	+#define addline(bp, text) addlinef(bp, "%s", text)
	+int anycb(int);
	+int bclear(struct buffer *);
	+int showbuffer(struct buffer , struct mgwin , int);
	+int augbname(char , const char , size_t);
	+struct mgwin popbuf(struct buffer , int);
	+int bufferinsert(int, int);
	+int usebuffer(int, int);
	+int notmodified(int, int);
	+int popbuftop(struct buffer *, int);
	+int getbufcwd(char *, size_t);
	+int checkdirty(struct buffer *);
	+int revertbuffer(int, int);
	+int dorevert(void);
	+int diffbuffer(int, int);
	+struct buffer findbuffer(char );
	+
	+/* display.c */
	+int vtresize(int, int, int);
	+void vtinit(void);
	+void vttidy(void);
	+void update(int);
	+int linenotoggle(int, int);
	+int colnotoggle(int, int);
	+
	+/* echo.c X */
	+void eerase(void);
	+int eyorn(const char *);
	+int eynorr(const char *);
	+int eyesno(const char *);
	+void ewprintf(const char *fmt, ...);
	+char eread(const char , char *, size_t, int, ...)
	+ __attribute__((__format__ (printf, 1, 5)));
	+int getxtra(struct list , struct list , int, int);
	+void free_file_list(struct list *);
	+
	+/* fileio.c */
	+int ffropen(FILE *, const char , struct buffer *);
	+void ffstat(FILE , struct buffer );
	+int ffwopen(FILE *, const char , struct buffer *);
	+int ffclose(FILE , struct buffer );
	+int ffputbuf(FILE , struct buffer , int);
	+int ffgetline(FILE , char , int, int *);
	+int fbackupfile(const char *);
	+char adjustname(const char , int);
	+char startupfile(char , char *);
	+int copy(char , char );
	+struct list make_file_list(char );
	+int fisdir(const char *);
	+int fchecktime(struct buffer *);
	+int fupdstat(struct buffer *);
	+int backuptohomedir(int, int);
	+int toggleleavetmp(int, int);
	+char expandtilde(const char );
	+
	+/* kbd.c X */
	+int do_meta(int, int);
	+int bsmap(int, int);
	+void ungetkey(int);
	+int getkey(int);
	+int doin(void);
	+int rescan(int, int);
	+int universal_argument(int, int);
	+int digit_argument(int, int);
	+int negative_argument(int, int);
	+int ask_selfinsert(int, int);
	+int selfinsert(int, int);
	+int quote(int, int);
	+
	+/* main.c */
	+int ctrlg(int, int);
	+int quit(int, int);
	+
	+/* ttyio.c */
	+void panic(char *);
	+
	+/* cinfo.c */
	+char getkeyname(char , size_t, int);
	+
	+/* basic.c */
	+int gotobol(int, int);
	+int backchar(int, int);
	+int gotoeol(int, int);
	+int forwchar(int, int);
	+int gotobob(int, int);
	+int gotoeob(int, int);
	+int forwline(int, int);
	+int backline(int, int);
	+void setgoal(void);
	+int getgoal(struct line *);
	+int forwpage(int, int);
	+int backpage(int, int);
	+int forw1page(int, int);
	+int back1page(int, int);
	+int pagenext(int, int);
	+void isetmark(void);
	+int setmark(int, int);
	+int clearmark(int, int);
	+int swapmark(int, int);
	+int gotoline(int, int);
	+int setlineno(int);
	+
	+/* util.c X */
	+int showcpos(int, int);
	+int getcolpos(struct mgwin *);
	+int twiddle(int, int);
	+int openline(int, int);
	+int enewline(int, int);
	+int deblank(int, int);
	+int justone(int, int);
	+int delwhite(int, int);
	+int delleadwhite(int, int);
	+int deltrailwhite(int, int);
	+int lfindent(int, int);
	+int indent(int, int);
	+int forwdel(int, int);
	+int backdel(int, int);
	+int space_to_tabstop(int, int);
	+int backtoindent(int, int);
	+int joinline(int, int);
	+
	+/* tags.c X */
	+int findtag(int, int);
	+int poptag(int, int);
	+int tagsvisit(int, int);
	+int curtoken(int, int, char *);
	+
	+/* cscope.c */
	+int cssymbol(int, int);
	+int csdefinition(int, int);
	+int csfuncalled(int, int);
	+int cscallerfuncs(int, int);
	+int csfindtext(int, int);
	+int csegrep(int, int);
	+int csfindfile(int, int);
	+int csfindinc(int, int);
	+int csnextfile(int, int);
	+int csnextmatch(int, int);
	+int csprevfile(int, int);
	+int csprevmatch(int, int);
	+int cscreatelist(int, int);
	+
	+/* extend.c X */
	+int insert(int, int);
	+int bindtokey(int, int);
	+int localbind(int, int);
	+int redefine_key(int, int);
	+int unbindtokey(int, int);
	+int localunbind(int, int);
	+int extend(int, int);
	+int evalexpr(int, int);
	+int evalbuffer(int, int);
	+int evalfile(int, int);
	+int load(const char *);
	+int excline(char *, int, int);
	+char skipwhite(char );
	+
	+/* help.c X */
	+int desckey(int, int);
	+int wallchart(int, int);
	+int help_help(int, int);
	+int apropos_command(int, int);
	+
	+/* paragraph.c X */
	+int gotobop(int, int);
	+int gotoeop(int, int);
	+int fillpara(int, int);
	+int killpara(int, int);
	+int fillword(int, int);
	+int setfillcol(int, int);
	+int markpara(int, int);
	+int transposepara(int, int);
	+int sentencespace(int, int);
	+
	+/* word.c X */
	+int backword(int, int);
	+int forwword(int, int);
	+int upperword(int, int);
	+int lowerword(int, int);
	+int capword(int, int);
	+int delfword(int, int);
	+int delbword(int, int);
	+int inword(void);
	+int transposeword(int, int);
	+
	+/* region.c X */
	+int killregion(int, int);
	+int copyregion(int, int);
	+int lowerregion(int, int);
	+int upperregion(int, int);
	+int prefixregion(int, int);
	+int setprefix(int, int);
	+int region_get_data(struct region , char , int);
	+void region_put_data(const char *, int);
	+int markbuffer(int, int);
	+int piperegion(int, int);
	+int shellcommand(int, int);
	+int pipeio(const char * const, char * const[], char * const, int,
	+ struct buffer *);
	+
	+/* search.c X */
	+int forwsearch(int, int);
	+int backsearch(int, int);
	+int searchagain(int, int);
	+int forwisearch(int, int);
	+int backisearch(int, int);
	+int queryrepl(int, int);
	+int forwsrch(void);
	+int backsrch(void);
	+int readpattern(char *);
	+
	+/* spawn.c X */
	+int spawncli(int, int);
	+
	+/* ttykbd.c X */
	+void ttykeymapinit(void);
	+void ttykeymaptidy(void);
	+
	+/* match.c X */
	+int showmatch(int, int);
	+
	+/* version.c X */
	+int showversion(int, int);
	+
	+/* macro.c X */
	+int definemacro(int, int);
	+int finishmacro(int, int);
	+int executemacro(int, int);
	+
	+/* modes.c X */
	+int indentmode(int, int);
	+int fillmode(int, int);
	+#ifdef NOTAB
	+int notabmode(int, int);
	+#endif /* NOTAB */
	+int overwrite_mode(int, int);
	+int set_default_mode(int,int);
	+
	+#ifdef REGEX
	+/* re_search.c X */
	+int re_forwsearch(int, int);
	+int re_backsearch(int, int);
	+int re_searchagain(int, int);
	+int re_queryrepl(int, int);
	+int re_repl(int, int);
	+int replstr(int, int);
	+int setcasefold(int, int);
	+int delmatchlines(int, int);
	+int delnonmatchlines(int, int);
	+int cntmatchlines(int, int);
	+int cntnonmatchlines(int, int);
	+#endif /* REGEX */
	+
	+/* undo.c X */
	+void free_undo_record(struct undo_rec *);
	+int undo_dump(int, int);
	+int undo_enabled(void);
	+int undo_enable(int, int);
	+int undo_add_boundary(int, int);
	+void undo_add_modified(void);
	+int undo_add_insert(struct line *, int, int);
	+int undo_add_delete(struct line *, int, int, int);
	+int undo_boundary_enable(int, int);
	+int undo_add_change(struct line *, int, int);
	+int undo(int, int);
	+
	+/* autoexec.c X */
	+int auto_execute(int, int);
	+PF find_autoexec(const char );
	+int add_autoexec(const char , const char );
	+
	+/* cmode.c X */
	+int cmode(int, int);
	+int cc_brace(int, int);
	+int cc_char(int, int);
	+int cc_tab(int, int);
	+int cc_indent(int, int);
	+int cc_lfindent(int, int);
	+
	+/* grep.c X */
	+int next_error(int, int);
	+int globalwdtoggle(int, int);
	+int compile(int, int);
	+
	+/* bell.c */
	+void bellinit(void);
	+int toggleaudiblebell(int, int);
	+int togglevisiblebell(int, int);
	+int dobeep_num(const char *, int);
	+int dobeep_msgs(const char , const char );
	+int dobeep_msg(const char *);
	+void dobeep(void);
	+
	+/* interpreter.c */
	+int foundparen(char *, int, int);
	+void cleanup(void);
	+
	+/*
	+ * Externals.
	+ */
	+extern struct buffer *bheadp;
	+extern struct buffer *curbp;
	+extern struct mgwin *curwp;
	+extern struct mgwin *wheadp;
	+extern struct vhead varhead;
	+extern int thisflag;
	+extern int lastflag;
	+extern int curgoal;
	+extern int startrow;
	+extern int epresf;
	+extern int sgarbf;
	+extern int mode;
	+extern int nrow;
	+extern int ncol;
	+extern int ttrow;
	+extern int ttcol;
	+extern int tttop;
	+extern int ttbot;
	+extern int tthue;
	+extern int defb_nmodes;
	+extern int defb_flag;
	+extern int doaudiblebell;
	+extern int dovisiblebell;
	+extern int dblspace;
	+extern int allbro;
	+extern int batch;
	+extern char cinfo[];
	+extern char *keystrings[];
	+extern char pat[NPAT];
	+extern char prompt[];
	+extern int tceeol;
	+extern int tcinsl;
	+extern int tcdell;
	+extern int rptcount; /* successive invocation count */
	+
	+/*
	+ * Extensions.
	+ */
	+extern int shownlprompt;
	+int togglenewlineprompt(int, int);
	Index: contrib/mg/dir.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/dir.c
	@@ -0,0 +1,183 @@
	+/* $OpenBSD: dir.c,v 1.31 2019/06/28 13:35:02 deraadt Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * Name: MG 2a
	+ * Directory management functions
	+ * Created: Ron Flax (ron@vsedev.vse.com)
	+ * Modified for MG 2a by Mic Kaczmarczik 03-Aug-1987
	+ */
	+
	+#include <sys/queue.h>
	+#include <sys/stat.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <string.h>
	+#include <unistd.h>
	+
	+#include "def.h"
	+
	+static char mgcwd[NFILEN];
	+
	+/*
	+ * Initialize anything the directory management routines need.
	+ */
	+void
	+dirinit(void)
	+{
	+ mgcwd[0] = '\0';
	+ if (getcwd(mgcwd, sizeof(mgcwd)) == NULL)
	+ ewprintf("Can't get current directory!");
	+ if (mgcwd[0] != '\0' && !(mgcwd[0] == '/' && mgcwd[1] == '\0'))
	+ (void)strlcat(mgcwd, "/", sizeof(mgcwd));
	+}
	+
	+/*
	+ * Change current working directory.
	+ */
	+/* ARGSUSED */
	+int
	+changedir(int f, int n)
	+{
	+ char bufc[NFILEN], *bufp;
	+
	+ (void)strlcpy(bufc, mgcwd, sizeof(bufc));
	+ if ((bufp = eread("Change default directory: ", bufc, NFILEN,
	+ EFDEF \| EFNEW \| EFCR \| EFFILE)) == NULL)
	+ return (ABORT);
	+ else if (bufp[0] == '\0')
	+ return (FALSE);
	+ /* Append trailing slash */
	+ if (chdir(bufc) == -1) {
	+ dobeep();
	+ ewprintf("Can't change dir to %s", bufc);
	+ return (FALSE);
	+ }
	+ if ((bufp = getcwd(mgcwd, sizeof(mgcwd))) == NULL) {
	+ if (bufc[0] == '/')
	+ (void)strlcpy(mgcwd, bufc, sizeof(mgcwd));
	+ else
	+ (void)strlcat(mgcwd, bufc, sizeof(mgcwd));
	+ }
	+ if (mgcwd[strlen(mgcwd) - 1] != '/')
	+ (void)strlcat(mgcwd, "/", sizeof(mgcwd));
	+ ewprintf("Current directory is now %s", mgcwd);
	+ return (TRUE);
	+}
	+
	+/*
	+ * Show current directory.
	+ */
	+/* ARGSUSED */
	+int
	+showcwdir(int f, int n)
	+{
	+ ewprintf("Current directory: %s", mgcwd);
	+ return (TRUE);
	+}
	+
	+int
	+getcwdir(char *buf, size_t len)
	+{
	+ if (strlcpy(buf, mgcwd, len) >= len)
	+ return (FALSE);
	+
	+ return (TRUE);
	+}
	+
	+/* Create the directory and it's parents. */
	+/* ARGSUSED */
	+int
	+makedir(int f, int n)
	+{
	+ return (ask_makedir());
	+}
	+
	+int
	+ask_makedir(void)
	+{
	+
	+ char bufc[NFILEN];
	+ char *path;
	+
	+ if (getbufcwd(bufc, sizeof(bufc)) != TRUE)
	+ return (ABORT);
	+ if ((path = eread("Make directory: ", bufc, NFILEN,
	+ EFDEF \| EFNEW \| EFCR \| EFFILE)) == NULL)
	+ return (ABORT);
	+ else if (path[0] == '\0')
	+ return (FALSE);
	+
	+ return (do_makedir(path));
	+}
	+
	+int
	+do_makedir(char *path)
	+{
	+ struct stat sb;
	+ int finished, ishere;
	+ mode_t dir_mode, f_mode, oumask;
	+ char *slash;
	+
	+ if ((path = adjustname(path, TRUE)) == NULL)
	+ return (FALSE);
	+
	+ /* Remove trailing slashes */
	+ slash = strrchr(path, '\0');
	+ while (--slash > path && *slash == '/')
	+ *slash = '\0';
	+
	+ slash = path;
	+
	+ oumask = umask(0);
	+ f_mode = 0777 & ~oumask;
	+ dir_mode = f_mode \| S_IWUSR \| S_IXUSR;
	+
	+ for (;;) {
	+ slash += strspn(slash, "/");
	+ slash += strcspn(slash, "/");
	+
	+ finished = (*slash == '\0');
	+ *slash = '\0';
	+
	+ ishere = !stat(path, &sb);
	+ if (finished && ishere) {
	+ dobeep();
	+ ewprintf("Cannot create directory %s: file exists",
	+ path);
	+ return(FALSE);
	+ } else if (!finished && ishere && S_ISDIR(sb.st_mode)) {
	+ *slash = '/';
	+ continue;
	+ }
	+
	+ if (mkdir(path, finished ? f_mode : dir_mode) == 0) {
	+ if (f_mode > 0777 && chmod(path, f_mode) == -1) {
	+ umask(oumask);
	+ return (ABORT);
	+ }
	+ } else {
	+ if (!ishere \|\| !S_ISDIR(sb.st_mode)) {
	+ if (!ishere) {
	+ dobeep();
	+ ewprintf("Creating directory: "
	+ "permission denied, %s", path);
	+ } else
	+ eerase();
	+
	+ umask(oumask);
	+ return (FALSE);
	+ }
	+ }
	+
	+ if (finished)
	+ break;
	+
	+ *slash = '/';
	+ }
	+
	+ eerase();
	+ umask(oumask);
	+ return (TRUE);
	+}
	Index: contrib/mg/dired.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/dired.c
	@@ -0,0 +1,1206 @@
	+/* $OpenBSD: dired.c,v 1.100 2021/05/02 14:13:17 lum Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/* dired module for mg 2a
	+ * by Robert A. Larson
	+ */
	+
	+#include <sys/queue.h>
	+#include <sys/resource.h>
	+#include <sys/stat.h>
	+#include <sys/time.h>
	+#include <sys/types.h>
	+#include <sys/wait.h>
	+#include <ctype.h>
	+#include <err.h>
	+#include <errno.h>
	+#include <fcntl.h>
	+#include <limits.h>
	+#include <signal.h>
	+#include <stdarg.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+#include <unistd.h>
	+
	+#include "def.h"
	+#include "funmap.h"
	+#include "kbd.h"
	+
	+void dired_init(void);
	+static int dired(int, int);
	+static int d_otherwindow(int, int);
	+static int d_undel(int, int);
	+static int d_undelbak(int, int);
	+static int d_findfile(int, int);
	+static int d_ffotherwindow(int, int);
	+static int d_expunge(int, int);
	+static int d_copy(int, int);
	+static int d_del(int, int);
	+static int d_rename(int, int);
	+static int d_exec(int, struct buffer , const char , const char *, ...);
	+static int d_shell_command(int, int);
	+static int d_create_directory(int, int);
	+static int d_makename(struct line , char , size_t);
	+static int d_warpdot(struct line , int );
	+static int d_forwpage(int, int);
	+static int d_backpage(int, int);
	+static int d_forwline(int, int);
	+static int d_backline(int, int);
	+static int d_killbuffer_cmd(int, int);
	+static int d_refreshbuffer(int, int);
	+static int d_filevisitalt(int, int);
	+static int d_gotofile(int, int);
	+static void reaper(int);
	+static int gotofile(char*);
	+static struct buffer refreshbuffer(struct buffer );
	+static int createlist(struct buffer *);
	+static void redelete(struct buffer *);
	+static char findfname(struct line , char *);
	+
	+extern struct keymap_s helpmap, cXmap, metamap;
	+
	+const char DDELCHAR = 'D';
	+
	+/*
	+ * Structure which holds a linked list of file names marked for
	+ * deletion. Used to maintain dired buffer 'state' between refreshes.
	+ */
	+struct delentry {
	+ SLIST_ENTRY(delentry) entry;
	+ char *fn;
	+};
	+SLIST_HEAD(slisthead, delentry) delhead = SLIST_HEAD_INITIALIZER(delhead);
	+
	+static PF dirednul[] = {
	+ setmark, /* ^@ */
	+ gotobol, /* ^A */
	+ backchar, /* ^B */
	+ rescan, /* ^C */
	+ d_del, /* ^D */
	+ gotoeol, /* ^E */
	+ forwchar, /* ^F */
	+ ctrlg, /* ^G */
	+ NULL, /* ^H */
	+};
	+
	+static PF diredcl[] = {
	+ reposition, /* ^L */
	+ d_findfile, /* ^M */
	+ d_forwline, /* ^N */
	+ rescan, /* ^O */
	+ d_backline, /* ^P */
	+ rescan, /* ^Q */
	+ backisearch, /* ^R */
	+ forwisearch, /* ^S */
	+ rescan, /* ^T */
	+ universal_argument, /* ^U */
	+ d_forwpage, /* ^V */
	+ rescan, /* ^W */
	+ NULL /* ^X */
	+};
	+
	+static PF diredcz[] = {
	+ spawncli, /* ^Z */
	+ NULL, /* esc */
	+ rescan, /* ^\ */
	+ rescan, /* ^] */
	+ rescan, /* ^^ */
	+ rescan, /* ^_ */
	+ d_forwline, /* SP */
	+ d_shell_command, /* ! */
	+ rescan, /* " */
	+ rescan, /* # */
	+ rescan, /* $ */
	+ rescan, /* % */
	+ rescan, /* & */
	+ rescan, /* ' */
	+ rescan, /* ( */
	+ rescan, /* ) */
	+ rescan, /* * */
	+ d_create_directory /* + */
	+};
	+
	+static PF direda[] = {
	+ d_filevisitalt, /* a */
	+ rescan, /* b */
	+ d_copy, /* c */
	+ d_del, /* d */
	+ d_findfile, /* e */
	+ d_findfile, /* f */
	+ d_refreshbuffer, /* g */
	+ rescan, /* h */
	+ rescan, /* i */
	+ d_gotofile /* j */
	+};
	+
	+static PF diredn[] = {
	+ d_forwline, /* n */
	+ d_ffotherwindow, /* o */
	+ d_backline, /* p */
	+ d_killbuffer_cmd, /* q */
	+ d_rename, /* r */
	+ rescan, /* s */
	+ rescan, /* t */
	+ d_undel, /* u */
	+ rescan, /* v */
	+ rescan, /* w */
	+ d_expunge /* x */
	+};
	+
	+static PF direddl[] = {
	+ d_undelbak /* del */
	+};
	+
	+static PF diredbp[] = {
	+ d_backpage /* v */
	+};
	+
	+static PF dirednull[] = {
	+ NULL
	+};
	+
	+static struct KEYMAPE (1) d_backpagemap = {
	+ 1,
	+ 1,
	+ rescan,
	+ {
	+ {
	+ 'v', 'v', diredbp, NULL
	+ }
	+ }
	+};
	+
	+static struct KEYMAPE (7) diredmap = {
	+ 7,
	+ 7,
	+ rescan,
	+ {
	+ {
	+ CCHR('@'), CCHR('H'), dirednul, (KEYMAP *) & helpmap
	+ },
	+ {
	+ CCHR('L'), CCHR('X'), diredcl, (KEYMAP *) & cXmap
	+ },
	+ {
	+ CCHR('['), CCHR('['), dirednull, (KEYMAP *) &
	+ d_backpagemap
	+ },
	+ {
	+ CCHR('Z'), '+', diredcz, (KEYMAP *) & metamap
	+ },
	+ {
	+ 'a', 'j', direda, NULL
	+ },
	+ {
	+ 'n', 'x', diredn, NULL
	+ },
	+ {
	+ CCHR('?'), CCHR('?'), direddl, NULL
	+ },
	+ }
	+};
	+
	+void
	+dired_init(void)
	+{
	+ funmap_add(dired, "dired", 1);
	+ funmap_add(d_create_directory, "dired-create-directory", 1);
	+ funmap_add(d_copy, "dired-do-copy", 1);
	+ funmap_add(d_expunge, "dired-do-flagged-delete", 0);
	+ funmap_add(d_rename, "dired-do-rename", 1);
	+ funmap_add(d_findfile, "dired-find-file", 1);
	+ funmap_add(d_ffotherwindow, "dired-find-file-other-window", 1);
	+ funmap_add(d_del, "dired-flag-file-deletion", 0);
	+ funmap_add(d_gotofile, "dired-goto-file", 1);
	+ funmap_add(d_forwline, "dired-next-line", 0);
	+ funmap_add(d_otherwindow, "dired-other-window", 0);
	+ funmap_add(d_backline, "dired-previous-line", 0);
	+ funmap_add(d_refreshbuffer, "dired-revert", 0);
	+ funmap_add(d_backpage, "dired-scroll-down", 0);
	+ funmap_add(d_forwpage, "dired-scroll-up", 0);
	+ funmap_add(d_shell_command, "dired-shell-command", 1);
	+ funmap_add(d_undel, "dired-unmark", 0);
	+ funmap_add(d_undelbak, "dired-unmark-backward", 0);
	+ funmap_add(d_killbuffer_cmd, "quit-window", 0);
	+ maps_add((KEYMAP *)&diredmap, "dired");
	+ dobindkey(fundamental_map, "dired", "^Xd");
	+}
	+
	+/* ARGSUSED */
	+int
	+dired(int f, int n)
	+{
	+ char dname[NFILEN], bufp, slash;
	+ struct buffer *bp;
	+
	+ if (curbp->b_fname[0] != '\0') {
	+ (void)strlcpy(dname, curbp->b_fname, sizeof(dname));
	+ if ((slash = strrchr(dname, '/')) != NULL) {
	+ *(slash + 1) = '\0';
	+ }
	+ } else {
	+ if (getcwd(dname, sizeof(dname)) == NULL)
	+ dname[0] = '\0';
	+ }
	+
	+ if ((bufp = eread("Dired (directory): ", dname, NFILEN,
	+ EFDEF \| EFNEW \| EFCR)) == NULL)
	+ return (ABORT);
	+ if (bufp[0] == '\0')
	+ return (FALSE);
	+ if ((bp = dired_(bufp)) == NULL)
	+ return (FALSE);
	+
	+ curbp = bp;
	+ return (showbuffer(bp, curwp, WFFULL \| WFMODE));
	+}
	+
	+/* ARGSUSED */
	+int
	+d_otherwindow(int f, int n)
	+{
	+ char dname[NFILEN], bufp, slash;
	+ struct buffer *bp;
	+ struct mgwin *wp;
	+
	+ if (curbp->b_fname[0] != '\0') {
	+ (void)strlcpy(dname, curbp->b_fname, sizeof(dname));
	+ if ((slash = strrchr(dname, '/')) != NULL) {
	+ *(slash + 1) = '\0';
	+ }
	+ } else {
	+ if (getcwd(dname, sizeof(dname)) == NULL)
	+ dname[0] = '\0';
	+ }
	+
	+ if ((bufp = eread("Dired other window: ", dname, NFILEN,
	+ EFDEF \| EFNEW \| EFCR)) == NULL)
	+ return (ABORT);
	+ else if (bufp[0] == '\0')
	+ return (FALSE);
	+ if ((bp = dired_(bufp)) == NULL)
	+ return (FALSE);
	+ if ((wp = popbuf(bp, WNONE)) == NULL)
	+ return (FALSE);
	+ curbp = bp;
	+ curwp = wp;
	+ return (TRUE);
	+}
	+
	+/* ARGSUSED */
	+int
	+d_del(int f, int n)
	+{
	+ if (n < 0)
	+ return (FALSE);
	+ while (n--) {
	+ if (d_warpdot(curwp->w_dotp, &curwp->w_doto) == TRUE) {
	+ lputc(curwp->w_dotp, 0, DDELCHAR);
	+ curbp->b_flag \|= BFDIREDDEL;
	+ }
	+ if (lforw(curwp->w_dotp) != curbp->b_headp) {
	+ curwp->w_dotp = lforw(curwp->w_dotp);
	+ curwp->w_dotline++;
	+ }
	+ }
	+ curwp->w_rflag \|= WFEDIT \| WFMOVE;
	+ return (d_warpdot(curwp->w_dotp, &curwp->w_doto));
	+}
	+
	+/* ARGSUSED */
	+int
	+d_undel(int f, int n)
	+{
	+ if (n < 0)
	+ return (d_undelbak(f, -n));
	+ while (n--) {
	+ if (llength(curwp->w_dotp) > 0)
	+ lputc(curwp->w_dotp, 0, ' ');
	+ if (lforw(curwp->w_dotp) != curbp->b_headp) {
	+ curwp->w_dotp = lforw(curwp->w_dotp);
	+ curwp->w_dotline++;
	+ }
	+ }
	+ curwp->w_rflag \|= WFEDIT \| WFMOVE;
	+ return (d_warpdot(curwp->w_dotp, &curwp->w_doto));
	+}
	+
	+/* ARGSUSED */
	+int
	+d_undelbak(int f, int n)
	+{
	+ if (n < 0)
	+ return (d_undel(f, -n));
	+ while (n--) {
	+ if (lback(curwp->w_dotp) != curbp->b_headp) {
	+ curwp->w_dotp = lback(curwp->w_dotp);
	+ curwp->w_dotline--;
	+ }
	+ if (llength(curwp->w_dotp) > 0)
	+ lputc(curwp->w_dotp, 0, ' ');
	+ }
	+ curwp->w_rflag \|= WFEDIT \| WFMOVE;
	+ return (d_warpdot(curwp->w_dotp, &curwp->w_doto));
	+}
	+
	+/* ARGSUSED */
	+int
	+d_findfile(int f, int n)
	+{
	+ struct buffer *bp;
	+ int s;
	+ char fname[NFILEN];
	+
	+ if ((s = d_makename(curwp->w_dotp, fname, sizeof(fname))) == ABORT)
	+ return (FALSE);
	+ if (s == TRUE)
	+ bp = dired_(fname);
	+ else
	+ bp = findbuffer(fname);
	+ if (bp == NULL)
	+ return (FALSE);
	+ curbp = bp;
	+ if (showbuffer(bp, curwp, WFFULL) != TRUE)
	+ return (FALSE);
	+ if (bp->b_fname[0] != 0)
	+ return (TRUE);
	+ return (readin(fname));
	+}
	+
	+/* ARGSUSED */
	+int
	+d_ffotherwindow(int f, int n)
	+{
	+ char fname[NFILEN];
	+ int s;
	+ struct buffer *bp;
	+ struct mgwin *wp;
	+
	+ if ((s = d_makename(curwp->w_dotp, fname, sizeof(fname))) == ABORT)
	+ return (FALSE);
	+ if ((bp = (s ? dired_(fname) : findbuffer(fname))) == NULL)
	+ return (FALSE);
	+ if ((wp = popbuf(bp, WNONE)) == NULL)
	+ return (FALSE);
	+ curbp = bp;
	+ curwp = wp;
	+ if (bp->b_fname[0] != 0)
	+ return (TRUE); /* never true for dired buffers */
	+ return (readin(fname));
	+}
	+
	+/* ARGSUSED */
	+int
	+d_expunge(int f, int n)
	+{
	+ struct line lp, nlp;
	+ char fname[NFILEN], sname[NFILEN];
	+ int tmp;
	+
	+ tmp = curwp->w_dotline;
	+ curwp->w_dotline = 0;
	+
	+ for (lp = bfirstlp(curbp); lp != curbp->b_headp; lp = nlp) {
	+ curwp->w_dotline++;
	+ nlp = lforw(lp);
	+ if (llength(lp) && lgetc(lp, 0) == 'D') {
	+ switch (d_makename(lp, fname, sizeof(fname))) {
	+ case ABORT:
	+ dobeep();
	+ ewprintf("Bad line in dired buffer");
	+ curwp->w_dotline = tmp;
	+ return (FALSE);
	+ case FALSE:
	+ if (unlink(fname) == -1) {
	+ (void)xbasename(sname, fname, NFILEN);
	+ dobeep();
	+ ewprintf("Could not delete '%s'", sname);
	+ curwp->w_dotline = tmp;
	+ return (FALSE);
	+ }
	+ break;
	+ case TRUE:
	+ if (rmdir(fname) == -1) {
	+ (void)xbasename(sname, fname, NFILEN);
	+ dobeep();
	+ ewprintf("Could not delete directory "
	+ "'%s'", sname);
	+ curwp->w_dotline = tmp;
	+ return (FALSE);
	+ }
	+ break;
	+ }
	+ lfree(lp);
	+ curwp->w_bufp->b_lines--;
	+ if (tmp > curwp->w_dotline)
	+ tmp--;
	+ curwp->w_rflag \|= WFFULL;
	+ }
	+ }
	+ curwp->w_dotline = tmp;
	+ d_warpdot(curwp->w_dotp, &curwp->w_doto);
	+
	+ /* we have deleted all items successfully, remove del flag */
	+ curbp->b_flag &= ~BFDIREDDEL;
	+
	+ return (TRUE);
	+}
	+
	+/* ARGSUSED */
	+int
	+d_copy(int f, int n)
	+{
	+ struct stat statbuf;
	+ char frname[NFILEN], toname[NFILEN], sname[NFILEN];
	+ char topath, bufp;
	+ int ret;
	+ size_t off;
	+ struct buffer *bp;
	+
	+ if (d_makename(curwp->w_dotp, frname, sizeof(frname)) != FALSE) {
	+ dobeep();
	+ ewprintf("Not a file");
	+ return (FALSE);
	+ }
	+ off = strlcpy(toname, curbp->b_fname, sizeof(toname));
	+ if (off >= sizeof(toname) - 1) { /* can't happen, really */
	+ dobeep();
	+ ewprintf("Directory name too long");
	+ return (FALSE);
	+ }
	+ (void)xbasename(sname, frname, NFILEN);
	+ bufp = eread("Copy %s to: ", toname, sizeof(toname),
	+ EFDEF \| EFNEW \| EFCR, sname);
	+ if (bufp == NULL)
	+ return (ABORT);
	+ else if (bufp[0] == '\0')
	+ return (FALSE);
	+
	+ topath = adjustname(toname, TRUE);
	+ if (stat(topath, &statbuf) == 0) {
	+ if (S_ISDIR(statbuf.st_mode)) {
	+ ret = snprintf(toname, sizeof(toname), "%s/%s",
	+ topath, sname);
	+ if (ret < 0 \|\| ret >= sizeof(toname) - 1) {
	+ dobeep();
	+ ewprintf("Directory name too long");
	+ return (FALSE);
	+ }
	+ topath = adjustname(toname, TRUE);
	+ }
	+ }
	+ if (topath == NULL)
	+ return (FALSE);
	+ if (strcmp(frname, topath) == 0) {
	+ ewprintf("Cannot copy to same file: %s", frname);
	+ return (TRUE);
	+ }
	+ ret = (copy(frname, topath) >= 0) ? TRUE : FALSE;
	+ if (ret != TRUE)
	+ return (ret);
	+ if ((bp = refreshbuffer(curbp)) == NULL)
	+ return (FALSE);
	+
	+ ewprintf("Copy: 1 file");
	+ return (showbuffer(bp, curwp, WFFULL \| WFMODE));
	+}
	+
	+/* ARGSUSED */
	+int
	+d_rename(int f, int n)
	+{
	+ struct stat statbuf;
	+ char frname[NFILEN], toname[NFILEN];
	+ char topath, bufp;
	+ int ret;
	+ size_t off;
	+ struct buffer *bp;
	+ char sname[NFILEN];
	+
	+ if (d_makename(curwp->w_dotp, frname, sizeof(frname)) != FALSE) {
	+ dobeep();
	+ ewprintf("Not a file");
	+ return (FALSE);
	+ }
	+ off = strlcpy(toname, curbp->b_fname, sizeof(toname));
	+ if (off >= sizeof(toname) - 1) { /* can't happen, really */
	+ dobeep();
	+ ewprintf("Name too long");
	+ return (FALSE);
	+ }
	+ (void)xbasename(sname, frname, NFILEN);
	+ bufp = eread("Rename %s to: ", toname,
	+ sizeof(toname), EFDEF \| EFNEW \| EFCR, sname);
	+ if (bufp == NULL)
	+ return (ABORT);
	+ else if (bufp[0] == '\0')
	+ return (FALSE);
	+
	+ topath = adjustname(toname, TRUE);
	+ if (stat(topath, &statbuf) == 0) {
	+ if (S_ISDIR(statbuf.st_mode)) {
	+ ret = snprintf(toname, sizeof(toname), "%s/%s",
	+ topath, sname);
	+ if (ret < 0 \|\| ret >= sizeof(toname) - 1) {
	+ dobeep();
	+ ewprintf("Directory name too long");
	+ return (FALSE);
	+ }
	+ topath = adjustname(toname, TRUE);
	+ }
	+ }
	+ if (topath == NULL)
	+ return (FALSE);
	+ if (strcmp(frname, topath) == 0) {
	+ ewprintf("Cannot move to same file: %s", frname);
	+ return (TRUE);
	+ }
	+ ret = (rename(frname, topath) >= 0) ? TRUE : FALSE;
	+ if (ret != TRUE)
	+ return (ret);
	+ if ((bp = refreshbuffer(curbp)) == NULL)
	+ return (FALSE);
	+
	+ ewprintf("Move: 1 file");
	+ return (showbuffer(bp, curwp, WFFULL \| WFMODE));
	+}
	+
	+/* ARGSUSED */
	+void
	+reaper(int signo __attribute__((unused)))
	+{
	+ int save_errno = errno, status;
	+
	+ while (waitpid(-1, &status, WNOHANG) >= 0)
	+ ;
	+ errno = save_errno;
	+}
	+
	+/*
	+ * Pipe the currently selected file through a shell command.
	+ */
	+/* ARGSUSED */
	+int
	+d_shell_command(int f, int n)
	+{
	+ char command[512], fname[PATH_MAX], *bufp;
	+ struct buffer *bp;
	+ struct mgwin *wp;
	+ char sname[NFILEN];
	+
	+ bp = bfind("Shell Command Output", TRUE);
	+ if (bclear(bp) != TRUE)
	+ return (ABORT);
	+
	+ if (d_makename(curwp->w_dotp, fname, sizeof(fname)) != FALSE) {
	+ dobeep();
	+ ewprintf("bad line");
	+ return (ABORT);
	+ }
	+
	+ command[0] = '\0';
	+ (void)xbasename(sname, fname, NFILEN);
	+ bufp = eread("! on %s: ", command, sizeof(command), EFNEW, sname);
	+ if (bufp == NULL)
	+ return (ABORT);
	+
	+ if (d_exec(0, bp, fname, "sh", "-c", command, NULL) != TRUE)
	+ return (ABORT);
	+
	+ if ((wp = popbuf(bp, WNONE)) == NULL)
	+ return (ABORT); /* XXX - free the buffer?? */
	+ curwp = wp;
	+ curbp = wp->w_bufp;
	+ return (TRUE);
	+}
	+
	+/*
	+ * Pipe input file to cmd and insert the command's output in the
	+ * given buffer. Each line will be prefixed with the given
	+ * number of spaces.
	+ */
	+static int
	+d_exec(int space, struct buffer bp, const char input, const char *cmd, ...)
	+{
	+ char buf[BUFSIZ];
	+ va_list ap;
	+ struct sigaction olda, newa;
	+ char *argv = NULL, cp;
	+ FILE *fin;
	+ int fds[2] = { -1, -1 };
	+ int infd = -1;
	+ int ret = (ABORT), n;
	+ pid_t pid;
	+
	+ if (sigaction(SIGCHLD, NULL, &olda) == -1)
	+ return (ABORT);
	+
	+ /* Find the number of arguments. */
	+ va_start(ap, cmd);
	+ for (n = 2; va_arg(ap, char *) != NULL; n++)
	+ ;
	+ va_end(ap);
	+
	+ /* Allocate and build the argv. */
	+ if ((argv = calloc(n, sizeof(*argv))) == NULL) {
	+ dobeep();
	+ ewprintf("Can't allocate argv : %s", strerror(errno));
	+ goto out;
	+ }
	+
	+ n = 1;
	+ argv[0] = (char *)cmd;
	+ va_start(ap, cmd);
	+ while ((argv[n] = va_arg(ap, char *)) != NULL)
	+ n++;
	+ va_end(ap);
	+
	+ if (input == NULL)
	+ input = "/dev/null";
	+
	+ if ((infd = open(input, O_RDONLY)) == -1) {
	+ dobeep();
	+ ewprintf("Can't open input file : %s", strerror(errno));
	+ goto out;
	+ }
	+
	+ if (pipe(fds) == -1) {
	+ dobeep();
	+ ewprintf("Can't create pipe : %s", strerror(errno));
	+ goto out;
	+ }
	+
	+ newa.sa_handler = reaper;
	+ newa.sa_flags = 0;
	+ if (sigaction(SIGCHLD, &newa, NULL) == -1)
	+ goto out;
	+
	+ if ((pid = fork()) == -1) {
	+ dobeep();
	+ ewprintf("Can't fork");
	+ goto out;
	+ }
	+
	+ switch (pid) {
	+ case 0: /* Child */
	+ close(fds[0]);
	+ dup2(infd, STDIN_FILENO);
	+ dup2(fds[1], STDOUT_FILENO);
	+ dup2(fds[1], STDERR_FILENO);
	+ if (execvp(argv[0], argv) == -1)
	+ ewprintf("Can't exec %s: %s", argv[0], strerror(errno));
	+ exit(1);
	+ break;
	+ default: /* Parent */
	+ close(infd);
	+ close(fds[1]);
	+ infd = fds[1] = -1;
	+ if ((fin = fdopen(fds[0], "r")) == NULL)
	+ goto out;
	+ while (fgets(buf, sizeof(buf), fin) != NULL) {
	+ cp = strrchr(buf, *bp->b_nlchr);
	+ if (cp == NULL && !feof(fin)) { /* too long a line */
	+ int c;
	+ addlinef(bp, "%*s%s...", space, "", buf);
	+ while ((c = getc(fin)) != EOF &&
	+ c != *bp->b_nlchr)
	+ ;
	+ continue;
	+ } else if (cp)
	+ *cp = '\0';
	+ addlinef(bp, "%*s%s", space, "", buf);
	+ }
	+ fclose(fin);
	+ break;
	+ }
	+ ret = (TRUE);
	+
	+out:
	+ if (sigaction(SIGCHLD, &olda, NULL) == -1)
	+ ewprintf("Warning, couldn't reset previous signal handler");
	+ if (fds[0] != -1)
	+ close(fds[0]);
	+ if (fds[1] != -1)
	+ close(fds[1]);
	+ if (infd != -1)
	+ close(infd);
	+ free(argv);
	+ return ret;
	+}
	+
	+/* ARGSUSED */
	+int
	+d_create_directory(int f, int n)
	+{
	+ int ret;
	+ struct buffer *bp;
	+
	+ ret = ask_makedir();
	+ if (ret != TRUE)
	+ return(ret);
	+
	+ if ((bp = refreshbuffer(curbp)) == NULL)
	+ return (FALSE);
	+
	+ return (showbuffer(bp, curwp, WFFULL \| WFMODE));
	+}
	+
	+/* ARGSUSED */
	+int
	+d_killbuffer_cmd(int f, int n)
	+{
	+ return(killbuffer_cmd(FFRAND, 0));
	+}
	+
	+int
	+d_refreshbuffer(int f, int n)
	+{
	+ struct buffer *bp;
	+
	+ if ((bp = refreshbuffer(curbp)) == NULL)
	+ return (FALSE);
	+
	+ return (showbuffer(bp, curwp, WFFULL \| WFMODE));
	+}
	+
	+/*
	+ * Kill then re-open the requested dired buffer.
	+ * If required, take a note of any files marked for deletion. Then once
	+ * the buffer has been re-opened, remark the same files as deleted.
	+ */
	+struct buffer *
	+refreshbuffer(struct buffer *bp)
	+{
	+ char *tmp_b_fname;
	+ int i, tmp_w_dotline, ddel = 0;
	+
	+ /* remember directory path to open later */
	+ tmp_b_fname = strdup(bp->b_fname);
	+ if (tmp_b_fname == NULL) {
	+ dobeep();
	+ ewprintf("Out of memory");
	+ return (NULL);
	+ }
	+ tmp_w_dotline = curwp->w_dotline;
	+
	+ /* create a list of files for deletion */
	+ if (bp->b_flag & BFDIREDDEL)
	+ ddel = createlist(bp);
	+
	+ killbuffer(bp);
	+
	+ /* dired_() uses findbuffer() to create new buffer */
	+ if ((bp = dired_(tmp_b_fname)) == NULL) {
	+ free(tmp_b_fname);
	+ return (NULL);
	+ }
	+ free(tmp_b_fname);
	+
	+ /* remark any previously deleted files with a 'D' */
	+ if (ddel)
	+ redelete(bp);
	+
	+ /* find dot line */
	+ bp->b_dotp = bfirstlp(bp);
	+ if (tmp_w_dotline > bp->b_lines)
	+ tmp_w_dotline = bp->b_lines - 1;
	+ for (i = 1; i < tmp_w_dotline; i++)
	+ bp->b_dotp = lforw(bp->b_dotp);
	+
	+ bp->b_dotline = i;
	+ bp->b_doto = 0;
	+ d_warpdot(bp->b_dotp, &bp->b_doto);
	+
	+ curbp = bp;
	+
	+ return (bp);
	+}
	+
	+static int
	+d_makename(struct line lp, char fn, size_t len)
	+{
	+ int start, nlen, ret;
	+ char *namep;
	+
	+ if (d_warpdot(lp, &start) == FALSE)
	+ return (ABORT);
	+ namep = &lp->l_text[start];
	+ nlen = llength(lp) - start;
	+
	+ ret = snprintf(fn, len, "%s%.*s", curbp->b_fname, nlen, namep);
	+ if (ret < 0 \|\| ret >= (int)len)
	+ return (ABORT); /* Name is too long. */
	+
	+ /* Return TRUE if the entry is a directory. */
	+ return ((lgetc(lp, 2) == 'd') ? TRUE : FALSE);
	+}
	+
	+#define NAME_FIELD 9
	+
	+static int
	+d_warpdot(struct line dotp, int doto)
	+{
	+ char *tp = dotp->l_text;
	+ int off = 0, field = 0, len;
	+
	+ /*
	+ * Find the byte offset to the (space-delimited) filename
	+ * field in formatted ls output.
	+ */
	+ len = llength(dotp);
	+ while (off < len) {
	+ if (tp[off++] == ' ') {
	+ if (++field == NAME_FIELD) {
	+ *doto = off;
	+ return (TRUE);
	+ }
	+ /* Skip the space. */
	+ while (off < len && tp[off] == ' ')
	+ off++;
	+ }
	+ }
	+ /* We didn't find the field. */
	+ *doto = 0;
	+ return (FALSE);
	+}
	+
	+static int
	+d_forwpage(int f, int n)
	+{
	+ forwpage(f \| FFRAND, n);
	+ return (d_warpdot(curwp->w_dotp, &curwp->w_doto));
	+}
	+
	+static int
	+d_backpage (int f, int n)
	+{
	+ backpage(f \| FFRAND, n);
	+ return (d_warpdot(curwp->w_dotp, &curwp->w_doto));
	+}
	+
	+static int
	+d_forwline (int f, int n)
	+{
	+ forwline(f \| FFRAND, n);
	+ return (d_warpdot(curwp->w_dotp, &curwp->w_doto));
	+}
	+
	+static int
	+d_backline (int f, int n)
	+{
	+ backline(f \| FFRAND, n);
	+ return (d_warpdot(curwp->w_dotp, &curwp->w_doto));
	+}
	+
	+int
	+d_filevisitalt (int f, int n)
	+{
	+ char fname[NFILEN];
	+
	+ if (d_makename(curwp->w_dotp, fname, sizeof(fname)) == ABORT)
	+ return (FALSE);
	+
	+ return(do_filevisitalt(fname));
	+}
	+
	+/*
	+ * XXX dname needs to have enough place to store an additional '/'.
	+ */
	+struct buffer *
	+dired_(char *dname)
	+{
	+ struct buffer *bp;
	+ int i;
	+ size_t len;
	+
	+ if ((dname = adjustname(dname, TRUE)) == NULL) {
	+ dobeep();
	+ ewprintf("Bad directory name");
	+ return (NULL);
	+ }
	+ /* this should not be done, instead adjustname() should get a flag */
	+ len = strlen(dname);
	+ if (dname[len - 1] != '/') {
	+ dname[len++] = '/';
	+ dname[len] = '\0';
	+ }
	+ if ((access(dname, R_OK \| X_OK)) == -1) {
	+ if (errno == EACCES) {
	+ dobeep();
	+ ewprintf("Permission denied: %s", dname);
	+ } else {
	+ dobeep();
	+ ewprintf("Error opening: %s", dname);
	+ }
	+ return (NULL);
	+ }
	+ for (bp = bheadp; bp != NULL; bp = bp->b_bufp) {
	+ if (strcmp(bp->b_fname, dname) == 0) {
	+ if (fchecktime(bp) != TRUE)
	+ ewprintf("Directory has changed on disk;"
	+ " type g to update Dired");
	+ return (bp);
	+ }
	+
	+ }
	+ bp = bfind(dname, TRUE);
	+ bp->b_flag \|= BFREADONLY \| BFIGNDIRTY;
	+
	+ if ((d_exec(2, bp, NULL, "ls", "-al", dname, NULL)) != TRUE)
	+ return (NULL);
	+
	+ /* Find the line with ".." on it. */
	+ bp->b_dotp = bfirstlp(bp);
	+ bp->b_dotline = 1;
	+ for (i = 0; i < bp->b_lines; i++) {
	+ bp->b_dotp = lforw(bp->b_dotp);
	+ bp->b_dotline++;
	+ if (d_warpdot(bp->b_dotp, &bp->b_doto) == FALSE)
	+ continue;
	+ if (strcmp(ltext(bp->b_dotp) + bp->b_doto, "..") == 0)
	+ break;
	+ }
	+
	+ /* We want dot on the entry right after "..", if possible. */
	+ if (++i < bp->b_lines - 2) {
	+ bp->b_dotp = lforw(bp->b_dotp);
	+ bp->b_dotline++;
	+ }
	+ d_warpdot(bp->b_dotp, &bp->b_doto);
	+
	+ (void)strlcpy(bp->b_fname, dname, sizeof(bp->b_fname));
	+ (void)strlcpy(bp->b_cwd, dname, sizeof(bp->b_cwd));
	+ if ((bp->b_modes[1] = name_mode("dired")) == NULL) {
	+ bp->b_modes[0] = name_mode("fundamental");
	+ dobeep();
	+ ewprintf("Could not find mode dired");
	+ return (NULL);
	+ }
	+ (void)fupdstat(bp);
	+ bp->b_nmodes = 1;
	+ return (bp);
	+}
	+
	+/*
	+ * Iterate through the lines of the dired buffer looking for files
	+ * collected in the linked list made in createlist(). If a line is found
	+ * replace 'D' as first char in a line. As lines are found, remove the
	+ * corresponding item from the linked list. Iterate for as long as there
	+ * are items in the linked list or until end of buffer is found.
	+ */
	+void
	+redelete(struct buffer *bp)
	+{
	+ struct delentry dt, d1 = NULL;
	+ struct line lp, nlp;
	+ char fname[NFILEN];
	+ char *p = fname;
	+ size_t plen, fnlen;
	+ int finished = 0;
	+
	+ /* reset the deleted file buffer flag until a deleted file is found */
	+ bp->b_flag &= ~BFDIREDDEL;
	+
	+ for (lp = bfirstlp(bp); lp != bp->b_headp; lp = nlp) {
	+ bp->b_dotp = lp;
	+ if ((p = findfname(lp, p)) == NULL) {
	+ nlp = lforw(lp);
	+ continue;
	+ }
	+ plen = strlen(p);
	+ SLIST_FOREACH_SAFE(d1, &delhead, entry, dt) {
	+ fnlen = strlen(d1->fn);
	+ if ((plen == fnlen) &&
	+ (strncmp(p, d1->fn, plen) == 0)) {
	+ lputc(bp->b_dotp, 0, DDELCHAR);
	+ bp->b_flag \|= BFDIREDDEL;
	+ SLIST_REMOVE(&delhead, d1, delentry, entry);
	+ if (SLIST_EMPTY(&delhead)) {
	+ finished = 1;
	+ break;
	+ }
	+ }
	+ }
	+ if (finished)
	+ break;
	+ nlp = lforw(lp);
	+ }
	+ while (!SLIST_EMPTY(&delhead)) {
	+ d1 = SLIST_FIRST(&delhead);
	+ SLIST_REMOVE_HEAD(&delhead, entry);
	+ free(d1->fn);
	+ free(d1);
	+ }
	+ return;
	+}
	+
	+/*
	+ * Create a list of files marked for deletion.
	+ */
	+int
	+createlist(struct buffer *bp)
	+{
	+ struct delentry d1 = NULL, d2;
	+ struct line lp, nlp;
	+ char fname[NFILEN];
	+ char *p = fname;
	+ int ret = FALSE;
	+
	+ for (lp = bfirstlp(bp); lp != bp->b_headp; lp = nlp) {
	+ /*
	+ * Check if the line has 'D' on the first char and if a valid
	+ * filename can be extracted from it.
	+ */
	+ if (((lp->l_text[0] != DDELCHAR)) \|\|
	+ ((p = findfname(lp, p)) == NULL)) {
	+ nlp = lforw(lp);
	+ continue;
	+ }
	+ if (SLIST_EMPTY(&delhead)) {
	+ if ((d1 = malloc(sizeof(struct delentry)))
	+ == NULL)
	+ return (ABORT);
	+ if ((d1->fn = strdup(p)) == NULL) {
	+ free(d1);
	+ return (ABORT);
	+ }
	+ SLIST_INSERT_HEAD(&delhead, d1, entry);
	+ } else {
	+ if ((d2 = malloc(sizeof(struct delentry)))
	+ == NULL) {
	+ free(d1->fn);
	+ free(d1);
	+ return (ABORT);
	+ }
	+ if ((d2->fn = strdup(p)) == NULL) {
	+ free(d1->fn);
	+ free(d1);
	+ free(d2);
	+ return (ABORT);
	+ }
	+ if (!d1)
	+ SLIST_INSERT_HEAD(&delhead, d2, entry);
	+ else
	+ SLIST_INSERT_AFTER(d1, d2, entry);
	+ d1 = d2;
	+ }
	+ ret = TRUE;
	+ nlp = lforw(lp);
	+ }
	+ return (ret);
	+}
	+
	+int
	+dired_jump(int f, int n)
	+{
	+ struct buffer *bp;
	+ const char *modename;
	+ char dname[NFILEN], *fname;
	+ int ret, i;
	+
	+ /*
	+ * We use fundamental mode in dired, so just check we aren't in
	+ * dired mode for this specific function. Seems like a corner
	+ * case at the moment.
	+ */
	+ for (i = 0; i <= curbp->b_nmodes; i++) {
	+ modename = curbp->b_modes[i]->p_name;
	+ if (strncmp(modename, "dired", 5) == 0)
	+ return (dobeep_msg("In dired mode already"));
	+ }
	+
	+ if (getbufcwd(dname, sizeof(dname)) != TRUE)
	+ return (FALSE);
	+
	+ fname = curbp->b_fname;
	+
	+ if ((bp = dired_(dname)) == NULL)
	+ return (FALSE);
	+ curbp = bp;
	+
	+ ret = showbuffer(bp, curwp, WFFULL \| WFMODE);
	+ if (ret != TRUE)
	+ return ret;
	+
	+ fname = adjustname(fname, TRUE);
	+ if (fname != NULL)
	+ gotofile(fname);
	+
	+ return (TRUE);
	+}
	+
	+int
	+d_gotofile(int f, int n)
	+{
	+ size_t lenfpath;
	+ char fpath[NFILEN];
	+ char fpth, fnp = NULL;
	+
	+ if (getbufcwd(fpath, sizeof(fpath)) != TRUE)
	+ fpath[0] = '\0';
	+ lenfpath = strlen(fpath);
	+ fnp = eread("Goto file: ", fpath, NFILEN,
	+ EFNEW \| EFCR \| EFFILE \| EFDEF);
	+ if (fnp == NULL)
	+ return (ABORT);
	+ else if (fnp[0] == '\0')
	+ return (FALSE);
	+
	+ fpth = adjustname(fpath, TRUE); /* Removes last '/' if dir... */
	+ if (fpth == NULL \|\| strlen(fpth) == lenfpath - 1) { /* ...hence -1. */
	+ ewprintf("No file to find"); /* Current directory given so */
	+ return (TRUE); /* return at present location. */
	+ }
	+ return gotofile(fpth);
	+}
	+
	+int
	+gotofile(char *fpth)
	+{
	+ struct line lp, nlp;
	+ char fname[NFILEN];
	+ char *p;
	+ int tmp;
	+
	+ (void)xbasename(fname, fpth, NFILEN);
	+ tmp = 0;
	+ for (lp = bfirstlp(curbp); lp != curbp->b_headp; lp = nlp) {
	+ tmp++;
	+ if ((p = findfname(lp, p)) == NULL) {
	+ nlp = lforw(lp);
	+ continue;
	+ }
	+ if (strcmp(fname, p) == 0) {
	+ curwp->w_dotp = lp;
	+ curwp->w_dotline = tmp;
	+ (void)d_warpdot(curwp->w_dotp, &curwp->w_doto);
	+ tmp--;
	+ break;
	+ }
	+ nlp = lforw(lp);
	+ }
	+ if (tmp == curbp->b_lines - 1) {
	+ ewprintf("File not found %s", fname);
	+ return (FALSE);
	+ } else {
	+ ewprintf("");
	+ return (TRUE);
	+ }
	+}
	+
	+/*
	+ * Look for and extract a file name on a dired buffer line.
	+ */
	+char *
	+findfname(struct line lp, char fn)
	+{
	+ int start;
	+
	+ (void)d_warpdot(lp, &start);
	+ if (start < 1)
	+ return NULL;
	+ fn = &lp->l_text[start];
	+ return fn;
	+}
	Index: contrib/mg/display.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/display.c
	@@ -0,0 +1,1081 @@
	+/* $OpenBSD: display.c,v 1.48 2017/07/06 19:27:37 schwarze Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * The functions in this file handle redisplay. The
	+ * redisplay system knows almost nothing about the editing
	+ * process; the editing functions do, however, set some
	+ * hints to eliminate a lot of the grinding. There is more
	+ * that can be done; the "vtputc" interface is a real
	+ * pig.
	+ */
	+
	+#include <sys/queue.h>
	+#include <ctype.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+#include <term.h>
	+
	+#include "def.h"
	+#include "kbd.h"
	+
	+/*
	+ * A video structure always holds
	+ * an array of characters whose length is equal to
	+ * the longest line possible. v_text is allocated
	+ * dynamically to fit the screen width.
	+ */
	+struct video {
	+ short v_hash; /* Hash code, for compares. */
	+ short v_flag; /* Flag word. */
	+ short v_color; /* Color of the line. */
	+ int v_cost; /* Cost of display. */
	+ char v_text; / The actual characters. */
	+};
	+
	+#define VFCHG 0x0001 /* Changed. */
	+#define VFHBAD 0x0002 /* Hash and cost are bad. */
	+#define VFEXT 0x0004 /* extended line (beond ncol) */
	+
	+/*
	+ * SCORE structures hold the optimal
	+ * trace trajectory, and the cost of redisplay, when
	+ * the dynamic programming redisplay code is used.
	+ */
	+struct score {
	+ int s_itrace; /* "i" index for track back. */
	+ int s_jtrace; /* "j" index for trace back. */
	+ int s_cost; /* Display cost. */
	+};
	+
	+void vtmove(int, int);
	+void vtputc(int);
	+void vtpute(int);
	+int vtputs(const char *);
	+void vteeol(void);
	+void updext(int, int);
	+void modeline(struct mgwin *, int);
	+void setscores(int, int);
	+void traceback(int, int, int, int);
	+void ucopy(struct video , struct video );
	+void uline(int, struct video , struct video );
	+void hash(struct video *);
	+
	+
	+int sgarbf = TRUE; /* TRUE if screen is garbage. */
	+int vtrow = HUGE; /* Virtual cursor row. */
	+int vtcol = HUGE; /* Virtual cursor column. */
	+int tthue = CNONE; /* Current color. */
	+int ttrow = HUGE; /* Physical cursor row. */
	+int ttcol = HUGE; /* Physical cursor column. */
	+int tttop = HUGE; /* Top of scroll region. */
	+int ttbot = HUGE; /* Bottom of scroll region. */
	+int lbound = 0; /* leftmost bound of the current */
	+ /* line being displayed */
	+
	+struct video *vscreen; / Edge vector, virtual. */
	+struct video *pscreen; / Edge vector, physical. */
	+struct video video; / Actual screen data. */
	+struct video blanks; /* Blank line image. */
	+
	+/*
	+ * This matrix is written as an array because
	+ * we do funny things in the "setscores" routine, which
	+ * is very compute intensive, to make the subscripts go away.
	+ * It would be "SCORE score[NROW][NROW]" in old speak.
	+ * Look at "setscores" to understand what is up.
	+ */
	+struct score score; / [NROW * NROW] */
	+
	+static int linenos = TRUE;
	+static int colnos = FALSE;
	+
	+/* Is macro recording enabled? */
	+extern int macrodef;
	+/* Is working directory global? */
	+extern int globalwd;
	+
	+/*
	+ * Since we don't have variables (we probably should) these are command
	+ * processors for changing the values of mode flags.
	+ */
	+/* ARGSUSED */
	+int
	+linenotoggle(int f, int n)
	+{
	+ if (f & FFARG)
	+ linenos = n > 0;
	+ else
	+ linenos = !linenos;
	+
	+ sgarbf = TRUE;
	+
	+ return (TRUE);
	+}
	+
	+/* ARGSUSED */
	+int
	+colnotoggle(int f, int n)
	+{
	+ if (f & FFARG)
	+ colnos = n > 0;
	+ else
	+ colnos = !colnos;
	+
	+ sgarbf = TRUE;
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * Reinit the display data structures, this is called when the terminal
	+ * size changes.
	+ */
	+int
	+vtresize(int force, int newrow, int newcol)
	+{
	+ int i;
	+ int rowchanged, colchanged;
	+ static int first_run = 1;
	+ struct video *vp;
	+
	+ if (newrow < 1 \|\| newcol < 1)
	+ return (FALSE);
	+
	+ rowchanged = (newrow != nrow);
	+ colchanged = (newcol != ncol);
	+
	+#define TRYREALLOC(a, n) do { \
	+ void *tmp; \
	+ if ((tmp = realloc((a), (n))) == NULL) { \
	+ panic("out of memory in display code"); \
	+ } \
	+ (a) = tmp; \
	+ } while (0)
	+
	+#define TRYREALLOCARRAY(a, n, m) do { \
	+ void *tmp; \
	+ if ((tmp = reallocarray((a), (n), (m))) == NULL) {\
	+ panic("out of memory in display code"); \
	+ } \
	+ (a) = tmp; \
	+ } while (0)
	+
	+ /* No update needed */
	+ if (!first_run && !force && !rowchanged && !colchanged)
	+ return (TRUE);
	+
	+ if (first_run)
	+ memset(&blanks, 0, sizeof(blanks));
	+
	+ if (rowchanged \|\| first_run) {
	+ int vidstart;
	+
	+ /*
	+ * This is not pretty.
	+ */
	+ if (nrow == 0)
	+ vidstart = 0;
	+ else
	+ vidstart = 2 * (nrow - 1);
	+
	+ /*
	+ * We're shrinking, free some internal data.
	+ */
	+ if (newrow < nrow) {
	+ for (i = 2 * (newrow - 1); i < 2 * (nrow - 1); i++) {
	+ free(video[i].v_text);
	+ video[i].v_text = NULL;
	+ }
	+ }
	+
	+ TRYREALLOCARRAY(score, newrow, newrow * sizeof(struct score));
	+ TRYREALLOCARRAY(vscreen, (newrow - 1), sizeof(struct video *));
	+ TRYREALLOCARRAY(pscreen, (newrow - 1), sizeof(struct video *));
	+ TRYREALLOCARRAY(video, (newrow - 1), 2 * sizeof(struct video));
	+
	+ /*
	+ * Zero-out the entries we just allocated.
	+ */
	+ for (i = vidstart; i < 2 * (newrow - 1); i++)
	+ memset(&video[i], 0, sizeof(struct video));
	+
	+ /*
	+ * Reinitialize vscreen and pscreen arrays completely.
	+ */
	+ vp = &video[0];
	+ for (i = 0; i < newrow - 1; ++i) {
	+ vscreen[i] = vp;
	+ ++vp;
	+ pscreen[i] = vp;
	+ ++vp;
	+ }
	+ }
	+ if (rowchanged \|\| colchanged \|\| first_run) {
	+ for (i = 0; i < 2 * (newrow - 1); i++)
	+ TRYREALLOC(video[i].v_text, newcol);
	+ TRYREALLOC(blanks.v_text, newcol);
	+ }
	+
	+ nrow = newrow;
	+ ncol = newcol;
	+
	+ if (ttrow > nrow)
	+ ttrow = nrow;
	+ if (ttcol > ncol)
	+ ttcol = ncol;
	+
	+ first_run = 0;
	+ return (TRUE);
	+}
	+
	+#undef TRYREALLOC
	+#undef TRYREALLOCARRAY
	+
	+/*
	+ * Initialize the data structures used
	+ * by the display code. The edge vectors used
	+ * to access the screens are set up. The operating
	+ * system's terminal I/O channel is set up. Fill the
	+ * "blanks" array with ASCII blanks. The rest is done
	+ * at compile time. The original window is marked
	+ * as needing full update, and the physical screen
	+ * is marked as garbage, so all the right stuff happens
	+ * on the first call to redisplay.
	+ */
	+void
	+vtinit(void)
	+{
	+ int i;
	+
	+ ttopen();
	+ ttinit();
	+
	+ /*
	+ * ttinit called ttresize(), which called vtresize(), so our data
	+ * structures are setup correctly.
	+ */
	+
	+ blanks.v_color = CTEXT;
	+ for (i = 0; i < ncol; ++i)
	+ blanks.v_text[i] = ' ';
	+}
	+
	+/*
	+ * Tidy up the virtual display system
	+ * in anticipation of a return back to the host
	+ * operating system. Right now all we do is position
	+ * the cursor to the last line, erase the line, and
	+ * close the terminal channel.
	+ */
	+void
	+vttidy(void)
	+{
	+ ttcolor(CTEXT);
	+ ttnowindow(); /* No scroll window. */
	+ ttmove(nrow - 1, 0); /* Echo line. */
	+ tteeol();
	+ tttidy();
	+ ttflush();
	+ ttclose();
	+}
	+
	+/*
	+ * Move the virtual cursor to an origin
	+ * 0 spot on the virtual display screen. I could
	+ * store the column as a character pointer to the spot
	+ * on the line, which would make "vtputc" a little bit
	+ * more efficient. No checking for errors.
	+ */
	+void
	+vtmove(int row, int col)
	+{
	+ vtrow = row;
	+ vtcol = col;
	+}
	+
	+/*
	+ * Write a character to the virtual display,
	+ * dealing with long lines and the display of unprintable
	+ * things like control characters. Also expand tabs every 8
	+ * columns. This code only puts printing characters into
	+ * the virtual display image. Special care must be taken when
	+ * expanding tabs. On a screen whose width is not a multiple
	+ * of 8, it is possible for the virtual cursor to hit the
	+ * right margin before the next tab stop is reached. This
	+ * makes the tab code loop if you are not careful.
	+ * Three guesses how we found this.
	+ */
	+void
	+vtputc(int c)
	+{
	+ struct video *vp;
	+
	+ c &= 0xff;
	+
	+ vp = vscreen[vtrow];
	+ if (vtcol >= ncol)
	+ vp->v_text[ncol - 1] = '$';
	+ else if (c == '\t'
	+#ifdef NOTAB
	+ && !(curbp->b_flag & BFNOTAB)
	+#endif
	+ ) {
	+ do {
	+ vtputc(' ');
	+ } while (vtcol < ncol && (vtcol & 0x07) != 0);
	+ } else if (ISCTRL(c)) {
	+ vtputc('^');
	+ vtputc(CCHR(c));
	+ } else if (isprint(c))
	+ vp->v_text[vtcol++] = c;
	+ else {
	+ char bf[5];
	+
	+ snprintf(bf, sizeof(bf), "\\%o", c);
	+ vtputs(bf);
	+ }
	+}
	+
	+/*
	+ * Put a character to the virtual screen in an extended line. If we are not
	+ * yet on left edge, don't print it yet. Check for overflow on the right
	+ * margin.
	+ */
	+void
	+vtpute(int c)
	+{
	+ struct video *vp;
	+
	+ c &= 0xff;
	+
	+ vp = vscreen[vtrow];
	+ if (vtcol >= ncol)
	+ vp->v_text[ncol - 1] = '$';
	+ else if (c == '\t'
	+#ifdef NOTAB
	+ && !(curbp->b_flag & BFNOTAB)
	+#endif
	+ ) {
	+ do {
	+ vtpute(' ');
	+ } while (((vtcol + lbound) & 0x07) != 0 && vtcol < ncol);
	+ } else if (ISCTRL(c) != FALSE) {
	+ vtpute('^');
	+ vtpute(CCHR(c));
	+ } else if (isprint(c)) {
	+ if (vtcol >= 0)
	+ vp->v_text[vtcol] = c;
	+ ++vtcol;
	+ } else {
	+ char bf[5], *cp;
	+
	+ snprintf(bf, sizeof(bf), "\\%o", c);
	+ for (cp = bf; *cp != '\0'; cp++)
	+ vtpute(*cp);
	+ }
	+}
	+
	+/*
	+ * Erase from the end of the software cursor to the end of the line on which
	+ * the software cursor is located. The display routines will decide if a
	+ * hardware erase to end of line command should be used to display this.
	+ */
	+void
	+vteeol(void)
	+{
	+ struct video *vp;
	+
	+ vp = vscreen[vtrow];
	+ while (vtcol < ncol)
	+ vp->v_text[vtcol++] = ' ';
	+}
	+
	+/*
	+ * Make sure that the display is
	+ * right. This is a three part process. First,
	+ * scan through all of the windows looking for dirty
	+ * ones. Check the framing, and refresh the screen.
	+ * Second, make sure that "currow" and "curcol" are
	+ * correct for the current window. Third, make the
	+ * virtual and physical screens the same.
	+ */
	+void
	+update(int modelinecolor)
	+{
	+ struct line *lp;
	+ struct mgwin *wp;
	+ struct video *vp1;
	+ struct video *vp2;
	+ int c, i, j;
	+ int hflag;
	+ int currow, curcol;
	+ int offs, size;
	+
	+ if (charswaiting())
	+ return;
	+ if (sgarbf) { /* must update everything */
	+ wp = wheadp;
	+ while (wp != NULL) {
	+ wp->w_rflag \|= WFMODE \| WFFULL;
	+ wp = wp->w_wndp;
	+ }
	+ }
	+ if (linenos \|\| colnos) {
	+ wp = wheadp;
	+ while (wp != NULL) {
	+ wp->w_rflag \|= WFMODE;
	+ wp = wp->w_wndp;
	+ }
	+ }
	+ hflag = FALSE; /* Not hard. */
	+ for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
	+ /*
	+ * Nothing to be done.
	+ */
	+ if (wp->w_rflag == 0)
	+ continue;
	+
	+ if ((wp->w_rflag & WFFRAME) == 0) {
	+ lp = wp->w_linep;
	+ for (i = 0; i < wp->w_ntrows; ++i) {
	+ if (lp == wp->w_dotp)
	+ goto out;
	+ if (lp == wp->w_bufp->b_headp)
	+ break;
	+ lp = lforw(lp);
	+ }
	+ }
	+ /*
	+ * Put the middle-line in place.
	+ */
	+ i = wp->w_frame;
	+ if (i > 0) {
	+ --i;
	+ if (i >= wp->w_ntrows)
	+ i = wp->w_ntrows - 1;
	+ } else if (i < 0) {
	+ i += wp->w_ntrows;
	+ if (i < 0)
	+ i = 0;
	+ } else
	+ i = wp->w_ntrows / 2; /* current center, no change */
	+
	+ /*
	+ * Find the line.
	+ */
	+ lp = wp->w_dotp;
	+ while (i != 0 && lback(lp) != wp->w_bufp->b_headp) {
	+ --i;
	+ lp = lback(lp);
	+ }
	+ wp->w_linep = lp;
	+ wp->w_rflag \|= WFFULL; /* Force full. */
	+ out:
	+ lp = wp->w_linep; /* Try reduced update. */
	+ i = wp->w_toprow;
	+ if ((wp->w_rflag & ~WFMODE) == WFEDIT) {
	+ while (lp != wp->w_dotp) {
	+ ++i;
	+ lp = lforw(lp);
	+ }
	+ vscreen[i]->v_color = CTEXT;
	+ vscreen[i]->v_flag \|= (VFCHG \| VFHBAD);
	+ vtmove(i, 0);
	+ for (j = 0; j < llength(lp); ++j)
	+ vtputc(lgetc(lp, j));
	+ vteeol();
	+ } else if ((wp->w_rflag & (WFEDIT \| WFFULL)) != 0) {
	+ hflag = TRUE;
	+ while (i < wp->w_toprow + wp->w_ntrows) {
	+ vscreen[i]->v_color = CTEXT;
	+ vscreen[i]->v_flag \|= (VFCHG \| VFHBAD);
	+ vtmove(i, 0);
	+ if (lp != wp->w_bufp->b_headp) {
	+ for (j = 0; j < llength(lp); ++j)
	+ vtputc(lgetc(lp, j));
	+ lp = lforw(lp);
	+ }
	+ vteeol();
	+ ++i;
	+ }
	+ }
	+ if ((wp->w_rflag & WFMODE) != 0)
	+ modeline(wp, modelinecolor);
	+ wp->w_rflag = 0;
	+ wp->w_frame = 0;
	+ }
	+ lp = curwp->w_linep; /* Cursor location. */
	+ currow = curwp->w_toprow;
	+ while (lp != curwp->w_dotp) {
	+ ++currow;
	+ lp = lforw(lp);
	+ }
	+ curcol = 0;
	+ i = 0;
	+ while (i < curwp->w_doto) {
	+ c = lgetc(lp, i++);
	+ if (c == '\t'
	+#ifdef NOTAB
	+ && !(curbp->b_flag & BFNOTAB)
	+#endif
	+ ) {
	+ curcol \|= 0x07;
	+ curcol++;
	+ } else if (ISCTRL(c) != FALSE)
	+ curcol += 2;
	+ else if (isprint(c))
	+ curcol++;
	+ else {
	+ char bf[5];
	+
	+ snprintf(bf, sizeof(bf), "\\%o", c);
	+ curcol += strlen(bf);
	+ }
	+ }
	+ if (curcol >= ncol - 1) { /* extended line. */
	+ /* flag we are extended and changed */
	+ vscreen[currow]->v_flag \|= VFEXT \| VFCHG;
	+ updext(currow, curcol); /* and output extended line */
	+ } else
	+ lbound = 0; /* not extended line */
	+
	+ /*
	+ * Make sure no lines need to be de-extended because the cursor is no
	+ * longer on them.
	+ */
	+ wp = wheadp;
	+ while (wp != NULL) {
	+ lp = wp->w_linep;
	+ i = wp->w_toprow;
	+ while (i < wp->w_toprow + wp->w_ntrows) {
	+ if (vscreen[i]->v_flag & VFEXT) {
	+ /* always flag extended lines as changed */
	+ vscreen[i]->v_flag \|= VFCHG;
	+ if ((wp != curwp) \|\| (lp != wp->w_dotp) \|\|
	+ (curcol < ncol - 1)) {
	+ vtmove(i, 0);
	+ for (j = 0; j < llength(lp); ++j)
	+ vtputc(lgetc(lp, j));
	+ vteeol();
	+ /* this line no longer is extended */
	+ vscreen[i]->v_flag &= ~VFEXT;
	+ }
	+ }
	+ lp = lforw(lp);
	+ ++i;
	+ }
	+ /* if garbaged then fix up mode lines */
	+ if (sgarbf != FALSE)
	+ vscreen[i]->v_flag \|= VFCHG;
	+ /* and onward to the next window */
	+ wp = wp->w_wndp;
	+ }
	+
	+ if (sgarbf != FALSE) { /* Screen is garbage. */
	+ sgarbf = FALSE; /* Erase-page clears. */
	+ epresf = FALSE; /* The message area. */
	+ tttop = HUGE; /* Forget where you set. */
	+ ttbot = HUGE; /* scroll region. */
	+ tthue = CNONE; /* Color unknown. */
	+ ttmove(0, 0);
	+ tteeop();
	+ for (i = 0; i < nrow - 1; ++i) {
	+ uline(i, vscreen[i], &blanks);
	+ ucopy(vscreen[i], pscreen[i]);
	+ }
	+ ttmove(currow, curcol - lbound);
	+ ttflush();
	+ return;
	+ }
	+ if (hflag != FALSE) { /* Hard update? */
	+ for (i = 0; i < nrow - 1; ++i) {/* Compute hash data. */
	+ hash(vscreen[i]);
	+ hash(pscreen[i]);
	+ }
	+ offs = 0; /* Get top match. */
	+ while (offs != nrow - 1) {
	+ vp1 = vscreen[offs];
	+ vp2 = pscreen[offs];
	+ if (vp1->v_color != vp2->v_color
	+ \|\| vp1->v_hash != vp2->v_hash)
	+ break;
	+ uline(offs, vp1, vp2);
	+ ucopy(vp1, vp2);
	+ ++offs;
	+ }
	+ if (offs == nrow - 1) { /* Might get it all. */
	+ ttmove(currow, curcol - lbound);
	+ ttflush();
	+ return;
	+ }
	+ size = nrow - 1; /* Get bottom match. */
	+ while (size != offs) {
	+ vp1 = vscreen[size - 1];
	+ vp2 = pscreen[size - 1];
	+ if (vp1->v_color != vp2->v_color
	+ \|\| vp1->v_hash != vp2->v_hash)
	+ break;
	+ uline(size - 1, vp1, vp2);
	+ ucopy(vp1, vp2);
	+ --size;
	+ }
	+ if ((size -= offs) == 0) /* Get screen size. */
	+ panic("Illegal screen size in update");
	+ setscores(offs, size); /* Do hard update. */
	+ traceback(offs, size, size, size);
	+ for (i = 0; i < size; ++i)
	+ ucopy(vscreen[offs + i], pscreen[offs + i]);
	+ ttmove(currow, curcol - lbound);
	+ ttflush();
	+ return;
	+ }
	+ for (i = 0; i < nrow - 1; ++i) { /* Easy update. */
	+ vp1 = vscreen[i];
	+ vp2 = pscreen[i];
	+ if ((vp1->v_flag & VFCHG) != 0) {
	+ uline(i, vp1, vp2);
	+ ucopy(vp1, vp2);
	+ }
	+ }
	+ ttmove(currow, curcol - lbound);
	+ ttflush();
	+}
	+
	+/*
	+ * Update a saved copy of a line,
	+ * kept in a video structure. The "vvp" is
	+ * the one in the "vscreen". The "pvp" is the one
	+ * in the "pscreen". This is called to make the
	+ * virtual and physical screens the same when
	+ * display has done an update.
	+ */
	+void
	+ucopy(struct video vvp, struct video pvp)
	+{
	+ vvp->v_flag &= ~VFCHG; /* Changes done. */
	+ pvp->v_flag = vvp->v_flag; /* Update model. */
	+ pvp->v_hash = vvp->v_hash;
	+ pvp->v_cost = vvp->v_cost;
	+ pvp->v_color = vvp->v_color;
	+ bcopy(vvp->v_text, pvp->v_text, ncol);
	+}
	+
	+/*
	+ * updext: update the extended line which the cursor is currently on at a
	+ * column greater than the terminal width. The line will be scrolled right or
	+ * left to let the user see where the cursor is.
	+ */
	+void
	+updext(int currow, int curcol)
	+{
	+ struct line lp; / pointer to current line */
	+ int j; /* index into line */
	+
	+ if (ncol < 2)
	+ return;
	+
	+ /*
	+ * calculate what column the left bound should be
	+ * (force cursor into middle half of screen)
	+ */
	+ lbound = curcol - (curcol % (ncol >> 1)) - (ncol >> 2);
	+
	+ /*
	+ * scan through the line outputing characters to the virtual screen
	+ * once we reach the left edge
	+ */
	+ vtmove(currow, -lbound); /* start scanning offscreen */
	+ lp = curwp->w_dotp; /* line to output */
	+ for (j = 0; j < llength(lp); ++j) /* until the end-of-line */
	+ vtpute(lgetc(lp, j));
	+ vteeol(); /* truncate the virtual line */
	+ vscreen[currow]->v_text[0] = '$'; /* and put a '$' in column 1 */
	+}
	+
	+/*
	+ * Update a single line. This routine only
	+ * uses basic functionality (no insert and delete character,
	+ * but erase to end of line). The "vvp" points at the video
	+ * structure for the line on the virtual screen, and the "pvp"
	+ * is the same for the physical screen. Avoid erase to end of
	+ * line when updating CMODE color lines, because of the way that
	+ * reverse video works on most terminals.
	+ */
	+void
	+uline(int row, struct video vvp, struct video pvp)
	+{
	+ char *cp1;
	+ char *cp2;
	+ char *cp3;
	+ char *cp4;
	+ char *cp5;
	+ int nbflag;
	+
	+ if (vvp->v_color != pvp->v_color) { /* Wrong color, do a */
	+ ttmove(row, 0); /* full redraw. */
	+#ifdef STANDOUT_GLITCH
	+ if (pvp->v_color != CTEXT && magic_cookie_glitch >= 0)
	+ tteeol();
	+#endif
	+ ttcolor(vvp->v_color);
	+#ifdef STANDOUT_GLITCH
	+ cp1 = &vvp->v_text[magic_cookie_glitch > 0 ? magic_cookie_glitch : 0];
	+ /*
	+ * The odd code for magic_cookie_glitch==0 is to avoid
	+ * putting the invisible glitch character on the next line.
	+ * (Hazeltine executive 80 model 30)
	+ */
	+ cp2 = &vvp->v_text[ncol - (magic_cookie_glitch >= 0 ?
	+ (magic_cookie_glitch != 0 ? magic_cookie_glitch : 1) : 0)];
	+#else
	+ cp1 = &vvp->v_text[0];
	+ cp2 = &vvp->v_text[ncol];
	+#endif
	+ while (cp1 != cp2) {
	+ ttputc(*cp1++);
	+ ++ttcol;
	+ }
	+ ttcolor(CTEXT);
	+ return;
	+ }
	+ cp1 = &vvp->v_text[0]; /* Compute left match. */
	+ cp2 = &pvp->v_text[0];
	+ while (cp1 != &vvp->v_text[ncol] && cp1[0] == cp2[0]) {
	+ ++cp1;
	+ ++cp2;
	+ }
	+ if (cp1 == &vvp->v_text[ncol]) /* All equal. */
	+ return;
	+ nbflag = FALSE;
	+ cp3 = &vvp->v_text[ncol]; /* Compute right match. */
	+ cp4 = &pvp->v_text[ncol];
	+ while (cp3[-1] == cp4[-1]) {
	+ --cp3;
	+ --cp4;
	+ if (cp3[0] != ' ') /* Note non-blanks in */
	+ nbflag = TRUE; /* the right match. */
	+ }
	+ cp5 = cp3; /* Is erase good? */
	+ if (nbflag == FALSE && vvp->v_color == CTEXT) {
	+ while (cp5 != cp1 && cp5[-1] == ' ')
	+ --cp5;
	+ /* Alcyon hack */
	+ if ((int) (cp3 - cp5) <= tceeol)
	+ cp5 = cp3;
	+ }
	+ /* Alcyon hack */
	+ ttmove(row, (int) (cp1 - &vvp->v_text[0]));
	+#ifdef STANDOUT_GLITCH
	+ if (vvp->v_color != CTEXT && magic_cookie_glitch > 0) {
	+ if (cp1 < &vvp->v_text[magic_cookie_glitch])
	+ cp1 = &vvp->v_text[magic_cookie_glitch];
	+ if (cp5 > &vvp->v_text[ncol - magic_cookie_glitch])
	+ cp5 = &vvp->v_text[ncol - magic_cookie_glitch];
	+ } else if (magic_cookie_glitch < 0)
	+#endif
	+ ttcolor(vvp->v_color);
	+ while (cp1 != cp5) {
	+ ttputc(*cp1++);
	+ ++ttcol;
	+ }
	+ if (cp5 != cp3) /* Do erase. */
	+ tteeol();
	+}
	+
	+/*
	+ * Redisplay the mode line for the window pointed to by the "wp".
	+ * This is the only routine that has any idea of how the mode line is
	+ * formatted. You can change the modeline format by hacking at this
	+ * routine. Called by "update" any time there is a dirty window. Note
	+ * that if STANDOUT_GLITCH is defined, first and last magic_cookie_glitch
	+ * characters may never be seen.
	+ */
	+void
	+modeline(struct mgwin *wp, int modelinecolor)
	+{
	+ int n, md;
	+ struct buffer *bp;
	+ char sl[21]; /* Overkill. Space for 2^64 in base 10. */
	+ int len;
	+
	+ n = wp->w_toprow + wp->w_ntrows; /* Location. */
	+ vscreen[n]->v_color = modelinecolor; /* Mode line color. */
	+ vscreen[n]->v_flag \|= (VFCHG \| VFHBAD); /* Recompute, display. */
	+ vtmove(n, 0); /* Seek to right line. */
	+ bp = wp->w_bufp;
	+ vtputc('-');
	+ vtputc('-');
	+ if ((bp->b_flag & BFREADONLY) != 0) {
	+ vtputc('%');
	+ if ((bp->b_flag & BFCHG) != 0)
	+ vtputc('*');
	+ else
	+ vtputc('%');
	+ } else if ((bp->b_flag & BFCHG) != 0) { /* "" if changed. /
	+ vtputc('*');
	+ vtputc('*');
	+ } else {
	+ vtputc('-');
	+ vtputc('-');
	+ }
	+ vtputc('-');
	+ n = 5;
	+ n += vtputs("Mg: ");
	+ if (bp->b_bname[0] != '\0')
	+ n += vtputs(&(bp->b_bname[0]));
	+ while (n < 42) { /* Pad out with blanks. */
	+ vtputc(' ');
	+ ++n;
	+ }
	+ vtputc('(');
	+ ++n;
	+ for (md = 0; ; ) {
	+ n += vtputs(bp->b_modes[md]->p_name);
	+ if (++md > bp->b_nmodes)
	+ break;
	+ vtputc('-');
	+ ++n;
	+ }
	+ /* XXX These should eventually move to a real mode */
	+ if (macrodef == TRUE)
	+ n += vtputs("-def");
	+ if (globalwd == TRUE)
	+ n += vtputs("-gwd");
	+ vtputc(')');
	+ ++n;
	+
	+ if (linenos && colnos)
	+ len = snprintf(sl, sizeof(sl), "--L%d--C%d", wp->w_dotline,
	+ getcolpos(wp));
	+ else if (linenos)
	+ len = snprintf(sl, sizeof(sl), "--L%d", wp->w_dotline);
	+ else if (colnos)
	+ len = snprintf(sl, sizeof(sl), "--C%d", getcolpos(wp));
	+ if ((linenos \|\| colnos) && len < sizeof(sl) && len != -1)
	+ n += vtputs(sl);
	+
	+ while (n < ncol) { /* Pad out. */
	+ vtputc('-');
	+ ++n;
	+ }
	+}
	+
	+/*
	+ * Output a string to the mode line, report how long it was.
	+ */
	+int
	+vtputs(const char *s)
	+{
	+ int n = 0;
	+
	+ while (*s != '\0') {
	+ vtputc(*s++);
	+ ++n;
	+ }
	+ return (n);
	+}
	+
	+/*
	+ * Compute the hash code for the line pointed to by the "vp".
	+ * Recompute it if necessary. Also set the approximate redisplay
	+ * cost. The validity of the hash code is marked by a flag bit.
	+ * The cost understand the advantages of erase to end of line.
	+ * Tuned for the VAX by Bob McNamara; better than it used to be on
	+ * just about any machine.
	+ */
	+void
	+hash(struct video *vp)
	+{
	+ int i, n;
	+ char *s;
	+
	+ if ((vp->v_flag & VFHBAD) != 0) { /* Hash bad. */
	+ s = &vp->v_text[ncol - 1];
	+ for (i = ncol; i != 0; --i, --s)
	+ if (*s != ' ')
	+ break;
	+ n = ncol - i; /* Erase cheaper? */
	+ if (n > tceeol)
	+ n = tceeol;
	+ vp->v_cost = i + n; /* Bytes + blanks. */
	+ for (n = 0; i != 0; --i, --s)
	+ n = (n << 5) + n + *s;
	+ vp->v_hash = n; /* Hash code. */
	+ vp->v_flag &= ~VFHBAD; /* Flag as all done. */
	+ }
	+}
	+
	+/*
	+ * Compute the Insert-Delete
	+ * cost matrix. The dynamic programming algorithm
	+ * described by James Gosling is used. This code assumes
	+ * that the line above the echo line is the last line involved
	+ * in the scroll region. This is easy to arrange on the VT100
	+ * because of the scrolling region. The "offs" is the origin 0
	+ * offset of the first row in the virtual/physical screen that
	+ * is being updated; the "size" is the length of the chunk of
	+ * screen being updated. For a full screen update, use offs=0
	+ * and size=nrow-1.
	+ *
	+ * Older versions of this code implemented the score matrix by
	+ * a two dimensional array of SCORE nodes. This put all kinds of
	+ * multiply instructions in the code! This version is written to
	+ * use a linear array and pointers, and contains no multiplication
	+ * at all. The code has been carefully looked at on the VAX, with
	+ * only marginal checking on other machines for efficiency. In
	+ * fact, this has been tuned twice! Bob McNamara tuned it even
	+ * more for the VAX, which is a big issue for him because of
	+ * the 66 line X displays.
	+ *
	+ * On some machines, replacing the "for (i=1; i<=size; ++i)" with
	+ * i = 1; do { } while (++i <=size)" will make the code quite a
	+ * bit better; but it looks ugly.
	+ */
	+void
	+setscores(int offs, int size)
	+{
	+ struct score *sp;
	+ struct score *sp1;
	+ struct video vp, pp;
	+ struct video vbase, pbase;
	+ int tempcost;
	+ int bestcost;
	+ int j, i;
	+
	+ vbase = &vscreen[offs - 1]; /* By hand CSE's. */
	+ pbase = &pscreen[offs - 1];
	+ score[0].s_itrace = 0; /* [0, 0] */
	+ score[0].s_jtrace = 0;
	+ score[0].s_cost = 0;
	+ sp = &score[1]; /* Row 0, inserts. */
	+ tempcost = 0;
	+ vp = &vbase[1];
	+ for (j = 1; j <= size; ++j) {
	+ sp->s_itrace = 0;
	+ sp->s_jtrace = j - 1;
	+ tempcost += tcinsl;
	+ tempcost += (*vp)->v_cost;
	+ sp->s_cost = tempcost;
	+ ++vp;
	+ ++sp;
	+ }
	+ sp = &score[nrow]; /* Column 0, deletes. */
	+ tempcost = 0;
	+ for (i = 1; i <= size; ++i) {
	+ sp->s_itrace = i - 1;
	+ sp->s_jtrace = 0;
	+ tempcost += tcdell;
	+ sp->s_cost = tempcost;
	+ sp += nrow;
	+ }
	+ sp1 = &score[nrow + 1]; /* [1, 1]. */
	+ pp = &pbase[1];
	+ for (i = 1; i <= size; ++i) {
	+ sp = sp1;
	+ vp = &vbase[1];
	+ for (j = 1; j <= size; ++j) {
	+ sp->s_itrace = i - 1;
	+ sp->s_jtrace = j;
	+ bestcost = (sp - nrow)->s_cost;
	+ if (j != size) /* Cd(A[i])=0 @ Dis. */
	+ bestcost += tcdell;
	+ tempcost = (sp - 1)->s_cost;
	+ tempcost += (*vp)->v_cost;
	+ if (i != size) /* Ci(B[j])=0 @ Dsj. */
	+ tempcost += tcinsl;
	+ if (tempcost < bestcost) {
	+ sp->s_itrace = i;
	+ sp->s_jtrace = j - 1;
	+ bestcost = tempcost;
	+ }
	+ tempcost = (sp - nrow - 1)->s_cost;
	+ if ((pp)->v_color != (vp)->v_color
	+ \|\| (pp)->v_hash != (vp)->v_hash)
	+ tempcost += (*vp)->v_cost;
	+ if (tempcost < bestcost) {
	+ sp->s_itrace = i - 1;
	+ sp->s_jtrace = j - 1;
	+ bestcost = tempcost;
	+ }
	+ sp->s_cost = bestcost;
	+ ++sp; /* Next column. */
	+ ++vp;
	+ }
	+ ++pp;
	+ sp1 += nrow; /* Next row. */
	+ }
	+}
	+
	+/*
	+ * Trace back through the dynamic programming cost
	+ * matrix, and update the screen using an optimal sequence
	+ * of redraws, insert lines, and delete lines. The "offs" is
	+ * the origin 0 offset of the chunk of the screen we are about to
	+ * update. The "i" and "j" are always started in the lower right
	+ * corner of the matrix, and imply the size of the screen.
	+ * A full screen traceback is called with offs=0 and i=j=nrow-1.
	+ * There is some do-it-yourself double subscripting here,
	+ * which is acceptable because this routine is much less compute
	+ * intensive then the code that builds the score matrix!
	+ */
	+void
	+traceback(int offs, int size, int i, int j)
	+{
	+ int itrace, jtrace;
	+ int k;
	+ int ninsl, ndraw, ndell;
	+
	+ if (i == 0 && j == 0) /* End of update. */
	+ return;
	+ itrace = score[(nrow * i) + j].s_itrace;
	+ jtrace = score[(nrow * i) + j].s_jtrace;
	+ if (itrace == i) { /* [i, j-1] */
	+ ninsl = 0; /* Collect inserts. */
	+ if (i != size)
	+ ninsl = 1;
	+ ndraw = 1;
	+ while (itrace != 0 \|\| jtrace != 0) {
	+ if (score[(nrow * itrace) + jtrace].s_itrace != itrace)
	+ break;
	+ jtrace = score[(nrow * itrace) + jtrace].s_jtrace;
	+ if (i != size)
	+ ++ninsl;
	+ ++ndraw;
	+ }
	+ traceback(offs, size, itrace, jtrace);
	+ if (ninsl != 0) {
	+ ttcolor(CTEXT);
	+ ttinsl(offs + j - ninsl, offs + size - 1, ninsl);
	+ }
	+ do { /* B[j], A[j] blank. */
	+ k = offs + j - ndraw;
	+ uline(k, vscreen[k], &blanks);
	+ } while (--ndraw);
	+ return;
	+ }
	+ if (jtrace == j) { /* [i-1, j] */
	+ ndell = 0; /* Collect deletes. */
	+ if (j != size)
	+ ndell = 1;
	+ while (itrace != 0 \|\| jtrace != 0) {
	+ if (score[(nrow * itrace) + jtrace].s_jtrace != jtrace)
	+ break;
	+ itrace = score[(nrow * itrace) + jtrace].s_itrace;
	+ if (j != size)
	+ ++ndell;
	+ }
	+ if (ndell != 0) {
	+ ttcolor(CTEXT);
	+ ttdell(offs + i - ndell, offs + size - 1, ndell);
	+ }
	+ traceback(offs, size, itrace, jtrace);
	+ return;
	+ }
	+ traceback(offs, size, itrace, jtrace);
	+ k = offs + j - 1;
	+ uline(k, vscreen[k], pscreen[offs + i - 1]);
	+}
	Index: contrib/mg/echo.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/echo.c
	@@ -0,0 +1,1020 @@
	+/* $OpenBSD: echo.c,v 1.68 2021/03/02 15:03:35 lum Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * Echo line reading and writing.
	+ *
	+ * Common routines for reading and writing characters in the echo line area
	+ * of the display screen. Used by the entire known universe.
	+ */
	+
	+#include <sys/queue.h>
	+#include <signal.h>
	+#include <stdarg.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+#include <term.h>
	+
	+#include "def.h"
	+#include "funmap.h"
	+#include "key.h"
	+#include "macro.h"
	+
	+static char veread(const char , char *, size_t, int, va_list)
	+ __attribute__((__format__ (printf, 1, 0)));
	+static int complt(int, int, char , size_t, int, int );
	+static int complt_list(int, char *, int);
	+static void eformat(const char *, va_list)
	+ __attribute__((__format__ (printf, 1, 0)));
	+static void eputi(int, int);
	+static void eputl(long, int);
	+static void eputs(const char *);
	+static void eputc(char);
	+static struct list copy_list(struct list );
	+
	+int epresf = FALSE; /* stuff in echo line flag */
	+
	+/*
	+ * Erase the echo line.
	+ */
	+void
	+eerase(void)
	+{
	+ ttcolor(CTEXT);
	+ ttmove(nrow - 1, 0);
	+ tteeol();
	+ ttflush();
	+ epresf = FALSE;
	+}
	+
	+/*
	+ * Ask a "yes" or "no" question. Return ABORT if the user answers the
	+ * question with the abort ("^G") character. Return FALSE for "no" and
	+ * TRUE for "yes". No formatting services are available. No newline
	+ * required.
	+ */
	+int
	+eyorn(const char *sp)
	+{
	+ int s;
	+
	+ if (inmacro)
	+ return (TRUE);
	+
	+ ewprintf("%s? (y or n) ", sp);
	+ for (;;) {
	+ s = getkey(FALSE);
	+ if (s == 'y' \|\| s == 'Y' \|\| s == ' ') {
	+ ewprintf("");
	+ return (TRUE);
	+ }
	+ if (s == 'n' \|\| s == 'N' \|\| s == CCHR('M')) {
	+ ewprintf("");
	+ return (FALSE);
	+ }
	+ if (s == CCHR('G')) {
	+ ewprintf("");
	+ return (ctrlg(FFRAND, 1));
	+ }
	+ ewprintf("Please answer y or n. %s? (y or n) ", sp);
	+ }
	+ /* NOTREACHED */
	+}
	+
	+/*
	+ * Ask a "yes", "no" or "revert" question. Return ABORT if the user answers
	+ * the question with the abort ("^G") character. Return FALSE for "no",
	+ * TRUE for "yes" and REVERT for "revert". No formatting services are
	+ * available. No newline required.
	+ */
	+int
	+eynorr(const char *sp)
	+{
	+ int s;
	+
	+ if (inmacro)
	+ return (TRUE);
	+
	+ ewprintf("%s? (y, n or r) ", sp);
	+ for (;;) {
	+ s = getkey(FALSE);
	+ if (s == 'y' \|\| s == 'Y' \|\| s == ' ') {
	+ ewprintf("");
	+ return (TRUE);
	+ }
	+ if (s == 'n' \|\| s == 'N' \|\| s == CCHR('M')) {
	+ ewprintf("");
	+ return (FALSE);
	+ }
	+ if (s == 'r' \|\| s == 'R') {
	+ ewprintf("");
	+ return (REVERT);
	+ }
	+ if (s == CCHR('G')) {
	+ ewprintf("");
	+ return (ctrlg(FFRAND, 1));
	+ }
	+ ewprintf("Please answer y, n or r.");
	+ }
	+ /* NOTREACHED */
	+}
	+
	+/*
	+ * Like eyorn, but for more important questions. User must type all of
	+ * "yes" or "no" and the trailing newline.
	+ */
	+int
	+eyesno(const char *sp)
	+{
	+ char buf[64], *rep;
	+
	+ if (inmacro)
	+ return (TRUE);
	+
	+ rep = eread("%s? (yes or no) ", buf, sizeof(buf),
	+ EFNUL \| EFNEW \| EFCR, sp);
	+ for (;;) {
	+ if (rep == NULL) {
	+ ewprintf("");
	+ return (ABORT);
	+ }
	+ if (rep[0] != '\0') {
	+ if (macrodef) {
	+ struct line *lp = maclcur;
	+
	+ maclcur = lp->l_bp;
	+ maclcur->l_fp = lp->l_fp;
	+ free(lp);
	+ }
	+ if (strcasecmp(rep, "yes") == 0) {
	+ ewprintf("");
	+ return (TRUE);
	+ }
	+ if (strcasecmp(rep, "no") == 0) {
	+ ewprintf("");
	+ return (FALSE);
	+ }
	+ }
	+ rep = eread("Please answer yes or no. %s? (yes or no) ",
	+ buf, sizeof(buf), EFNUL \| EFNEW \| EFCR, sp);
	+ }
	+ /* NOTREACHED */
	+}
	+
	+/*
	+ * This is the general "read input from the echo line" routine. The basic
	+ * idea is that the prompt string "prompt" is written to the echo line, and
	+ * a one line reply is read back into the supplied "buf" (with maximum
	+ * length "len").
	+ * XXX: When checking for an empty return value, always check rep, not buf
	+ * as buf may be freed in pathological cases.
	+ */
	+char *
	+eread(const char fmt, char buf, size_t nbuf, int flag, ...)
	+{
	+ va_list ap;
	+ char *rep;
	+
	+ va_start(ap, flag);
	+ rep = veread(fmt, buf, nbuf, flag, ap);
	+ va_end(ap);
	+ return (rep);
	+}
	+
	+static char *
	+veread(const char fp, char buf, size_t nbuf, int flag, va_list ap)
	+{
	+ int dynbuf = (buf == NULL);
	+ int cpos, epos; /* cursor, end position in buf */
	+ int c, i, y;
	+ int cplflag; /* display completion list */
	+ int cwin = FALSE; /* completion list created */
	+ int mr, ml; /* match left/right arrows */
	+ int esc; /* position in esc pattern */
	+ struct buffer bp; / completion list buffer */
	+ struct mgwin wp; / window for compl list */
	+ int match; /* esc match found */
	+ int cc, rr; /* saved ttcol, ttrow */
	+ char ret; / return value */
	+
	+ static char emptyval[] = ""; /* XXX hackish way to return err msg*/
	+
	+ if (inmacro) {
	+ if (dynbuf) {
	+ if ((buf = malloc(maclcur->l_used + 1)) == NULL)
	+ return (NULL);
	+ } else if (maclcur->l_used >= nbuf)
	+ return (NULL);
	+ bcopy(maclcur->l_text, buf, maclcur->l_used);
	+ buf[maclcur->l_used] = '\0';
	+ maclcur = maclcur->l_fp;
	+ return (buf);
	+ }
	+ epos = cpos = 0;
	+ ml = mr = esc = 0;
	+ cplflag = FALSE;
	+
	+ if ((flag & EFNEW) != 0 \|\| ttrow != nrow - 1) {
	+ ttcolor(CTEXT);
	+ ttmove(nrow - 1, 0);
	+ epresf = TRUE;
	+ } else
	+ eputc(' ');
	+ eformat(fp, ap);
	+ if ((flag & EFDEF) != 0) {
	+ if (buf == NULL)
	+ return (NULL);
	+ eputs(buf);
	+ epos = cpos += strlen(buf);
	+ }
	+ tteeol();
	+ ttflush();
	+ for (;;) {
	+ c = getkey(FALSE);
	+ if ((flag & EFAUTO) != 0 && c == CCHR('I')) {
	+ if (cplflag == TRUE) {
	+ complt_list(flag, buf, cpos);
	+ cwin = TRUE;
	+ } else if (complt(flag, c, buf, nbuf, epos, &i) == TRUE) {
	+ cplflag = TRUE;
	+ epos += i;
	+ cpos = epos;
	+ }
	+ continue;
	+ }
	+ cplflag = FALSE;
	+
	+ if (esc > 0) { /* ESC sequence started */
	+ match = 0;
	+ if (ml == esc && key_left[ml] && c == key_left[ml]) {
	+ match++;
	+ if (key_left[++ml] == '\0') {
	+ c = CCHR('B');
	+ esc = 0;
	+ }
	+ }
	+ if (mr == esc && key_right[mr] && c == key_right[mr]) {
	+ match++;
	+ if (key_right[++mr] == '\0') {
	+ c = CCHR('F');
	+ esc = 0;
	+ }
	+ }
	+ if (match == 0) {
	+ esc = 0;
	+ continue;
	+ /* hack. how do we know esc pattern is done? */
	+ }
	+ if (esc > 0) {
	+ esc++;
	+ continue;
	+ }
	+ }
	+ switch (c) {
	+ case CCHR('A'): /* start of line */
	+ while (cpos > 0) {
	+ if (ISCTRL(buf[--cpos]) != FALSE) {
	+ ttputc('\b');
	+ --ttcol;
	+ }
	+ ttputc('\b');
	+ --ttcol;
	+ }
	+ ttflush();
	+ break;
	+ case CCHR('D'):
	+ if (cpos != epos) {
	+ tteeol();
	+ epos--;
	+ rr = ttrow;
	+ cc = ttcol;
	+ for (i = cpos; i < epos; i++) {
	+ buf[i] = buf[i + 1];
	+ eputc(buf[i]);
	+ }
	+ ttmove(rr, cc);
	+ ttflush();
	+ }
	+ break;
	+ case CCHR('E'): /* end of line */
	+ while (cpos < epos) {
	+ eputc(buf[cpos++]);
	+ }
	+ ttflush();
	+ break;
	+ case CCHR('B'): /* back */
	+ if (cpos > 0) {
	+ if (ISCTRL(buf[--cpos]) != FALSE) {
	+ ttputc('\b');
	+ --ttcol;
	+ }
	+ ttputc('\b');
	+ --ttcol;
	+ ttflush();
	+ }
	+ break;
	+ case CCHR('F'): /* forw */
	+ if (cpos < epos) {
	+ eputc(buf[cpos++]);
	+ ttflush();
	+ }
	+ break;
	+ case CCHR('Y'): /* yank from kill buffer */
	+ i = 0;
	+ while ((y = kremove(i++)) >= 0 && y != *curbp->b_nlchr) {
	+ int t;
	+ if (dynbuf && epos + 1 >= nbuf) {
	+ void *newp;
	+ size_t newsize = epos + epos + 16;
	+ if ((newp = realloc(buf, newsize))
	+ == NULL)
	+ goto memfail;
	+ buf = newp;
	+ nbuf = newsize;
	+ }
	+ if (!dynbuf && epos + 1 >= nbuf) {
	+ dobeep();
	+ ewprintf("Line too long. Press Control-g to escape.");
	+ goto skipkey;
	+ }
	+ for (t = epos; t > cpos; t--)
	+ buf[t] = buf[t - 1];
	+ buf[cpos++] = (char)y;
	+ epos++;
	+ eputc((char)y);
	+ cc = ttcol;
	+ rr = ttrow;
	+ for (t = cpos; t < epos; t++)
	+ eputc(buf[t]);
	+ ttmove(rr, cc);
	+ }
	+ ttflush();
	+ break;
	+ case CCHR('K'): /* copy here-EOL to kill buffer */
	+ kdelete();
	+ for (i = cpos; i < epos; i++)
	+ kinsert(buf[i], KFORW);
	+ tteeol();
	+ epos = cpos;
	+ ttflush();
	+ break;
	+ case CCHR('['):
	+ ml = mr = esc = 1;
	+ break;
	+ case CCHR('J'):
	+ c = CCHR('M');
	+ /* FALLTHROUGH */
	+ case CCHR('M'): /* return, done */
	+ /* if there's nothing in the minibuffer, abort */
	+ if (epos == 0 && !(flag & EFNUL)) {
	+ (void)ctrlg(FFRAND, 0);
	+ ttflush();
	+ return (NULL);
	+ }
	+ if ((flag & EFFUNC) != 0) {
	+ if (complt(flag, c, buf, nbuf, epos, &i)
	+ == FALSE)
	+ continue;
	+ if (i > 0)
	+ epos += i;
	+ }
	+ buf[epos] = '\0';
	+ if ((flag & EFCR) != 0) {
	+ ttputc(CCHR('M'));
	+ ttflush();
	+ }
	+ if (macrodef) {
	+ struct line *lp;
	+
	+ if ((lp = lalloc(cpos)) == NULL)
	+ goto memfail;
	+ lp->l_fp = maclcur->l_fp;
	+ maclcur->l_fp = lp;
	+ lp->l_bp = maclcur;
	+ maclcur = lp;
	+ bcopy(buf, lp->l_text, cpos);
	+ }
	+ ret = buf;
	+ goto done;
	+ case CCHR('G'): /* bell, abort */
	+ eputc(CCHR('G'));
	+ (void)ctrlg(FFRAND, 0);
	+ ttflush();
	+ ret = NULL;
	+ goto done;
	+ case CCHR('H'): /* rubout, erase */
	+ case CCHR('?'):
	+ if (cpos != 0) {
	+ y = buf[--cpos];
	+ epos--;
	+ ttputc('\b');
	+ ttcol--;
	+ if (ISCTRL(y) != FALSE) {
	+ ttputc('\b');
	+ ttcol--;
	+ }
	+ rr = ttrow;
	+ cc = ttcol;
	+ for (i = cpos; i < epos; i++) {
	+ buf[i] = buf[i + 1];
	+ eputc(buf[i]);
	+ }
	+ ttputc(' ');
	+ if (ISCTRL(y) != FALSE) {
	+ ttputc(' ');
	+ ttputc('\b');
	+ }
	+ ttputc('\b');
	+ ttmove(rr, cc);
	+ ttflush();
	+ }
	+ break;
	+ case CCHR('X'): /* kill line */
	+ case CCHR('U'):
	+ while (cpos != 0) {
	+ ttputc('\b');
	+ ttputc(' ');
	+ ttputc('\b');
	+ --ttcol;
	+ if (ISCTRL(buf[--cpos]) != FALSE) {
	+ ttputc('\b');
	+ ttputc(' ');
	+ ttputc('\b');
	+ --ttcol;
	+ }
	+ epos--;
	+ }
	+ ttflush();
	+ break;
	+ case CCHR('W'): /* kill to beginning of word */
	+ while ((cpos > 0) && !ISWORD(buf[cpos - 1])) {
	+ ttputc('\b');
	+ ttputc(' ');
	+ ttputc('\b');
	+ --ttcol;
	+ if (ISCTRL(buf[--cpos]) != FALSE) {
	+ ttputc('\b');
	+ ttputc(' ');
	+ ttputc('\b');
	+ --ttcol;
	+ }
	+ epos--;
	+ }
	+ while ((cpos > 0) && ISWORD(buf[cpos - 1])) {
	+ ttputc('\b');
	+ ttputc(' ');
	+ ttputc('\b');
	+ --ttcol;
	+ if (ISCTRL(buf[--cpos]) != FALSE) {
	+ ttputc('\b');
	+ ttputc(' ');
	+ ttputc('\b');
	+ --ttcol;
	+ }
	+ epos--;
	+ }
	+ ttflush();
	+ break;
	+ case CCHR('\\'):
	+ case CCHR('Q'): /* quote next */
	+ c = getkey(FALSE);
	+ /* FALLTHROUGH */
	+ default:
	+ if (dynbuf && epos + 1 >= nbuf) {
	+ void *newp;
	+ size_t newsize = epos + epos + 16;
	+ if ((newp = realloc(buf, newsize)) == NULL)
	+ goto memfail;
	+ buf = newp;
	+ nbuf = newsize;
	+ }
	+ if (!dynbuf && epos + 1 >= nbuf) {
	+ dobeep();
	+ ewprintf("Line too long. Press Control-g to escape.");
	+ goto skipkey;
	+ }
	+ for (i = epos; i > cpos; i--)
	+ buf[i] = buf[i - 1];
	+ buf[cpos++] = (char)c;
	+ epos++;
	+ eputc((char)c);
	+ cc = ttcol;
	+ rr = ttrow;
	+ for (i = cpos; i < epos; i++)
	+ eputc(buf[i]);
	+ ttmove(rr, cc);
	+ ttflush();
	+ }
	+
	+skipkey: /* ignore key press */
	+;
	+ }
	+done:
	+ if (cwin == TRUE) {
	+ /* blow away cpltion window */
	+ bp = bfind("Completions", TRUE);
	+ if ((wp = popbuf(bp, WEPHEM)) != NULL) {
	+ if (wp->w_flag & WEPHEM) {
	+ curwp = wp;
	+ delwind(FFRAND, 1);
	+ } else {
	+ killbuffer(bp);
	+ }
	+ }
	+ }
	+ return (ret);
	+memfail:
	+ if (dynbuf && buf)
	+ free(buf);
	+ dobeep();
	+ ewprintf("Out of memory");
	+ return (emptyval);
	+}
	+
	+/*
	+ * Do completion on a list of objects.
	+ * c is SPACE, TAB, or CR
	+ * return TRUE if matched (or partially matched)
	+ * FALSE is result is ambiguous,
	+ * ABORT on error.
	+ */
	+static int
	+complt(int flags, int c, char buf, size_t nbuf, int cpos, int nx)
	+{
	+ struct list lh, lh2;
	+ struct list *wholelist = NULL;
	+ int i, nxtra, nhits, bxtra, msglen, nshown;
	+ int wflag = FALSE;
	+ char *msg;
	+
	+ lh = lh2 = NULL;
	+
	+ if ((flags & EFFUNC) != 0) {
	+ buf[cpos] = '\0';
	+ wholelist = lh = complete_function_list(buf);
	+ } else if ((flags & EFBUF) != 0) {
	+ lh = &(bheadp->b_list);
	+ } else if ((flags & EFFILE) != 0) {
	+ buf[cpos] = '\0';
	+ wholelist = lh = make_file_list(buf);
	+ } else
	+ panic("broken complt call: flags");
	+
	+ if (c == ' ')
	+ wflag = TRUE;
	+ else if (c != '\t' && c != CCHR('M'))
	+ panic("broken complt call: c");
	+
	+ nhits = 0;
	+ nxtra = HUGE;
	+
	+ for (; lh != NULL; lh = lh->l_next) {
	+ if (memcmp(buf, lh->l_name, cpos) != 0)
	+ continue;
	+ if (nhits == 0)
	+ lh2 = lh;
	+ ++nhits;
	+ if (lh->l_name[cpos] == '\0')
	+ nxtra = -1; /* exact match */
	+ else {
	+ bxtra = getxtra(lh, lh2, cpos, wflag);
	+ if (bxtra < nxtra)
	+ nxtra = bxtra;
	+ lh2 = lh;
	+ }
	+ }
	+ if (nhits == 0)
	+ msg = " [No match]";
	+ else if (nhits > 1 && nxtra == 0)
	+ msg = " [Ambiguous. Ctrl-G to cancel]";
	+ else {
	+ /*
	+ * Being lazy - ought to check length, but all things
	+ * autocompleted have known types/lengths.
	+ */
	+ if (nxtra < 0 && nhits > 1 && c == ' ')
	+ nxtra = 1; /* ??? */
	+ for (i = 0; i < nxtra && cpos < nbuf; ++i) {
	+ buf[cpos] = lh2->l_name[cpos];
	+ eputc(buf[cpos++]);
	+ }
	+ /* XXX should grow nbuf */
	+ ttflush();
	+ free_file_list(wholelist);
	+ *nx = nxtra;
	+ if (nxtra < 0 && c != CCHR('M')) /* exact */
	+ *nx = 0;
	+ return (TRUE);
	+ }
	+
	+ /*
	+ * wholelist is NULL if we are doing buffers. Want to free lists
	+ * that were created for us, but not the buffer list!
	+ */
	+ free_file_list(wholelist);
	+
	+ /* Set up backspaces, etc., being mindful of echo line limit. */
	+ msglen = strlen(msg);
	+ nshown = (ttcol + msglen + 2 > ncol) ?
	+ ncol - ttcol - 2 : msglen;
	+ eputs(msg);
	+ ttcol -= (i = nshown); /* update ttcol! */
	+ while (i--) /* move back before msg */
	+ ttputc('\b');
	+ ttflush(); /* display to user */
	+ i = nshown;
	+ while (i--) /* blank out on next flush */
	+ eputc(' ');
	+ ttcol -= (i = nshown); /* update ttcol on BS's */
	+ while (i--)
	+ ttputc('\b'); /* update ttcol again! */
	+ *nx = nxtra;
	+ return ((nhits > 0) ? TRUE : FALSE);
	+}
	+
	+/*
	+ * Do completion on a list of objects, listing instead of completing.
	+ */
	+static int
	+complt_list(int flags, char *buf, int cpos)
	+{
	+ struct list lh, lh2, *lh3;
	+ struct list *wholelist = NULL;
	+ struct buffer *bp;
	+ int i, maxwidth, width;
	+ int preflen = 0;
	+ int oldrow = ttrow;
	+ int oldcol = ttcol;
	+ int oldhue = tthue;
	+ char *linebuf;
	+ size_t linesize, len;
	+ char *cp;
	+
	+ lh = NULL;
	+
	+ ttflush();
	+
	+ /* The results are put into a completion buffer. */
	+ bp = bfind("Completions", TRUE);
	+ if (bclear(bp) == FALSE)
	+ return (FALSE);
	+ bp->b_flag \|= BFREADONLY;
	+
	+ /*
	+ * First get the list of objects. This list may contain only
	+ * the ones that complete what has been typed, or may be the
	+ * whole list of all objects of this type. They are filtered
	+ * later in any case. Set wholelist if the list has been
	+ * cons'ed up just for us, so we can free it later. We have
	+ * to copy the buffer list for this function even though we
	+ * didn't for complt. The sorting code does destructive
	+ * changes to the list, which we don't want to happen to the
	+ * main buffer list!
	+ */
	+ if ((flags & EFBUF) != 0)
	+ wholelist = lh = copy_list(&(bheadp->b_list));
	+ else if ((flags & EFFUNC) != 0) {
	+ buf[cpos] = '\0';
	+ wholelist = lh = complete_function_list(buf);
	+ } else if ((flags & EFFILE) != 0) {
	+ buf[cpos] = '\0';
	+ wholelist = lh = make_file_list(buf);
	+ /*
	+ * We don't want to display stuff up to the / for file
	+ * names preflen is the list of a prefix of what the
	+ * user typed that should not be displayed.
	+ */
	+ cp = strrchr(buf, '/');
	+ if (cp)
	+ preflen = cp - buf + 1;
	+ } else
	+ panic("broken complt call: flags");
	+
	+ /*
	+ * Sort the list, since users expect to see it in alphabetic
	+ * order.
	+ */
	+ lh2 = lh;
	+ while (lh2 != NULL) {
	+ lh3 = lh2->l_next;
	+ while (lh3 != NULL) {
	+ if (strcmp(lh2->l_name, lh3->l_name) > 0) {
	+ cp = lh2->l_name;
	+ lh2->l_name = lh3->l_name;
	+ lh3->l_name = cp;
	+ }
	+ lh3 = lh3->l_next;
	+ }
	+ lh2 = lh2->l_next;
	+ }
	+
	+ /*
	+ * First find max width of object to be displayed, so we can
	+ * put several on a line.
	+ */
	+ maxwidth = 0;
	+ lh2 = lh;
	+ while (lh2 != NULL) {
	+ for (i = 0; i < cpos; ++i) {
	+ if (buf[i] != lh2->l_name[i])
	+ break;
	+ }
	+ if (i == cpos) {
	+ width = strlen(lh2->l_name);
	+ if (width > maxwidth)
	+ maxwidth = width;
	+ }
	+ lh2 = lh2->l_next;
	+ }
	+ maxwidth += 1 - preflen;
	+
	+ /*
	+ * Now do the display. Objects are written into linebuf until
	+ * it fills, and then put into the help buffer.
	+ */
	+ linesize = (ncol > maxwidth ? ncol : maxwidth) + 1;
	+ if ((linebuf = malloc(linesize)) == NULL) {
	+ free_file_list(wholelist);
	+ return (FALSE);
	+ }
	+ width = 0;
	+
	+ /*
	+ * We're going to strlcat() into the buffer, so it has to be
	+ * NUL terminated.
	+ */
	+ linebuf[0] = '\0';
	+ for (lh2 = lh; lh2 != NULL; lh2 = lh2->l_next) {
	+ for (i = 0; i < cpos; ++i) {
	+ if (buf[i] != lh2->l_name[i])
	+ break;
	+ }
	+ /* if we have a match */
	+ if (i == cpos) {
	+ /* if it wraps */
	+ if ((width + maxwidth) > ncol) {
	+ addline(bp, linebuf);
	+ linebuf[0] = '\0';
	+ width = 0;
	+ }
	+ len = strlcat(linebuf, lh2->l_name + preflen,
	+ linesize);
	+ width += maxwidth;
	+ if (len < width && width < linesize) {
	+ /* pad so the objects nicely line up */
	+ memset(linebuf + len, ' ',
	+ maxwidth - strlen(lh2->l_name + preflen));
	+ linebuf[width] = '\0';
	+ }
	+ }
	+ }
	+ if (width > 0)
	+ addline(bp, linebuf);
	+ free(linebuf);
	+
	+ /*
	+ * Note that we free lists only if they are put in wholelist lists
	+ * that were built just for us should be freed. However when we use
	+ * the buffer list, obviously we don't want it freed.
	+ */
	+ free_file_list(wholelist);
	+ popbuftop(bp, WEPHEM); /* split the screen and put up the help
	+ * buffer */
	+ update(CMODE); /* needed to make the new stuff actually
	+ * appear */
	+ ttmove(oldrow, oldcol); /* update leaves cursor in arbitrary place */
	+ ttcolor(oldhue); /* with arbitrary color */
	+ ttflush();
	+ return (0);
	+}
	+
	+/*
	+ * The "lp1" and "lp2" point to list structures. The "cpos" is a horizontal
	+ * position in the name. Return the longest block of characters that can be
	+ * autocompleted at this point. Sometimes the two symbols are the same, but
	+ * this is normal.
	+ */
	+int
	+getxtra(struct list lp1, struct list lp2, int cpos, int wflag)
	+{
	+ int i;
	+
	+ i = cpos;
	+ for (;;) {
	+ if (lp1->l_name[i] != lp2->l_name[i])
	+ break;
	+ if (lp1->l_name[i] == '\0')
	+ break;
	+ ++i;
	+ if (wflag && !ISWORD(lp1->l_name[i - 1]))
	+ break;
	+ }
	+ return (i - cpos);
	+}
	+
	+/*
	+ * Special "printf" for the echo line. Each call to "ewprintf" starts a
	+ * new line in the echo area, and ends with an erase to end of the echo
	+ * line. The formatting is done by a call to the standard formatting
	+ * routine.
	+ */
	+void
	+ewprintf(const char *fmt, ...)
	+{
	+ va_list ap;
	+
	+ if (inmacro)
	+ return;
	+
	+ va_start(ap, fmt);
	+ ttcolor(CTEXT);
	+ ttmove(nrow - 1, 0);
	+ eformat(fmt, ap);
	+ va_end(ap);
	+ tteeol();
	+ ttflush();
	+ epresf = TRUE;
	+}
	+
	+/*
	+ * Printf style formatting. This is called by "ewprintf" to provide
	+ * formatting services to its clients. The move to the start of the
	+ * echo line, and the erase to the end of the echo line, is done by
	+ * the caller.
	+ * %c prints the "name" of the supplied character.
	+ * %k prints the name of the current key (and takes no arguments).
	+ * %d prints a decimal integer
	+ * %o prints an octal integer
	+ * %p prints a pointer
	+ * %s prints a string
	+ * %ld prints a long word
	+ * Anything else is echoed verbatim
	+ */
	+static void
	+eformat(const char *fp, va_list ap)
	+{
	+ char kname[NKNAME], tmp[100], *cp;
	+ int c;
	+
	+ while ((c = *fp++) != '\0') {
	+ if (c != '%')
	+ eputc(c);
	+ else {
	+ c = *fp++;
	+ switch (c) {
	+ case 'c':
	+ getkeyname(kname, sizeof(kname),
	+ va_arg(ap, int));
	+ eputs(kname);
	+ break;
	+
	+ case 'k':
	+ for (cp = kname, c = 0; c < key.k_count; c++) {
	+ if (c)
	+ *cp++ = ' ';
	+ cp = getkeyname(cp, sizeof(kname) -
	+ (cp - kname) - 1, key.k_chars[c]);
	+ }
	+ eputs(kname);
	+ break;
	+
	+ case 'd':
	+ eputi(va_arg(ap, int), 10);
	+ break;
	+
	+ case 'o':
	+ eputi(va_arg(ap, int), 8);
	+ break;
	+
	+ case 'p':
	+ snprintf(tmp, sizeof(tmp), "%p",
	+ va_arg(ap, void *));
	+ eputs(tmp);
	+ break;
	+
	+ case 's':
	+ eputs(va_arg(ap, char *));
	+ break;
	+
	+ case 'l':
	+ /* explicit longword */
	+ c = *fp++;
	+ switch (c) {
	+ case 'd':
	+ eputl(va_arg(ap, long), 10);
	+ break;
	+ default:
	+ eputc(c);
	+ break;
	+ }
	+ break;
	+
	+ default:
	+ eputc(c);
	+ }
	+ }
	+ }
	+}
	+
	+/*
	+ * Put integer, in radix "r".
	+ */
	+static void
	+eputi(int i, int r)
	+{
	+ int q;
	+
	+ if (i < 0) {
	+ eputc('-');
	+ i = -i;
	+ }
	+ if ((q = i / r) != 0)
	+ eputi(q, r);
	+ eputc(i % r + '0');
	+}
	+
	+/*
	+ * Put long, in radix "r".
	+ */
	+static void
	+eputl(long l, int r)
	+{
	+ long q;
	+
	+ if (l < 0) {
	+ eputc('-');
	+ l = -l;
	+ }
	+ if ((q = l / r) != 0)
	+ eputl(q, r);
	+ eputc((int)(l % r) + '0');
	+}
	+
	+/*
	+ * Put string.
	+ */
	+static void
	+eputs(const char *s)
	+{
	+ int c;
	+
	+ while ((c = *s++) != '\0')
	+ eputc(c);
	+}
	+
	+/*
	+ * Put character. Watch for control characters, and for the line getting
	+ * too long.
	+ */
	+static void
	+eputc(char c)
	+{
	+ if (ttcol + 2 < ncol) {
	+ if (ISCTRL(c)) {
	+ eputc('^');
	+ c = CCHR(c);
	+ }
	+ ttputc(c);
	+ ++ttcol;
	+ }
	+}
	+
	+void
	+free_file_list(struct list *lp)
	+{
	+ struct list *next;
	+
	+ while (lp) {
	+ next = lp->l_next;
	+ free(lp->l_name);
	+ free(lp);
	+ lp = next;
	+ }
	+}
	+
	+static struct list *
	+copy_list(struct list *lp)
	+{
	+ struct list current, last, *nxt;
	+
	+ last = NULL;
	+ while (lp) {
	+ current = malloc(sizeof(struct list));
	+ if (current == NULL) {
	+ /* Free what we have allocated so far */
	+ for (current = last; current; current = nxt) {
	+ nxt = current->l_next;
	+ free(current->l_name);
	+ free(current);
	+ }
	+ return (NULL);
	+ }
	+ current->l_next = last;
	+ current->l_name = strdup(lp->l_name);
	+ last = current;
	+ lp = lp->l_next;
	+ }
	+ return (last);
	+}
	Index: contrib/mg/extend.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/extend.c
	@@ -0,0 +1,942 @@
	+/* $OpenBSD: extend.c,v 1.75 2021/05/06 14:16:12 lum Exp $ */
	+/* This file is in the public domain. */
	+
	+/*
	+ * Extended (M-x) commands, rebinding, and startup file processing.
	+ */
	+
	+#include <sys/queue.h>
	+#include <sys/types.h>
	+#include <regex.h>
	+#include <ctype.h>
	+#include <limits.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+
	+#include "chrdef.h"
	+#include "def.h"
	+#include "funmap.h"
	+#include "kbd.h"
	+#include "key.h"
	+#include "macro.h"
	+
	+static int remap(KEYMAP , int, PF, KEYMAP );
	+static KEYMAP reallocmap(KEYMAP );
	+static void fixmap(KEYMAP , KEYMAP , KEYMAP *);
	+static int dobind(KEYMAP , const char , int);
	+static char parsetoken(char );
	+static int bindkey(KEYMAP *, const char , KCHAR *, int);
	+
	+/*
	+ * Insert a string, mainly for use from macros (created by selfinsert).
	+ */
	+/* ARGSUSED */
	+int
	+insert(int f, int n)
	+{
	+ char buf[BUFSIZE], bufp, cp;
	+ int count, c;
	+
	+ if (inmacro) {
	+ while (--n >= 0) {
	+ for (count = 0; count < maclcur->l_used; count++) {
	+ if ((((c = maclcur->l_text[count]) ==
	+ *curbp->b_nlchr)
	+ ? lnewline() : linsert(1, c)) != TRUE)
	+ return (FALSE);
	+ }
	+ }
	+ maclcur = maclcur->l_fp;
	+ return (TRUE);
	+ }
	+ if (n == 1)
	+ /* CFINS means selfinsert can tack on the end */
	+ thisflag \|= CFINS;
	+
	+ if ((bufp = eread("Insert: ", buf, sizeof(buf), EFNEW)) == NULL)
	+ return (ABORT);
	+ else if (bufp[0] == '\0')
	+ return (FALSE);
	+ while (--n >= 0) {
	+ cp = buf;
	+ while (*cp) {
	+ if (((cp == curbp->b_nlchr) ?
	+ lnewline() : linsert(1, *cp))
	+ != TRUE)
	+ return (FALSE);
	+ cp++;
	+ }
	+ }
	+ return (TRUE);
	+}
	+
	+/*
	+ * Bind a key to a function. Cases range from the trivial (replacing an
	+ * existing binding) to the extremely complex (creating a new prefix in a
	+ * map_element that already has one, so the map_element must be split,
	+ * but the keymap doesn't have enough room for another map_element, so
	+ * the keymap is reallocated). No attempt is made to reclaim space no
	+ * longer used, if this is a problem flags must be added to indicate
	+ * malloced versus static storage in both keymaps and map_elements.
	+ * Structure assignments would come in real handy, but K&R based compilers
	+ * don't have them. Care is taken so running out of memory will leave
	+ * the keymap in a usable state.
	+ * Parameters are:
	+ * curmap: pointer to the map being changed
	+ * c: character being changed
	+ * funct: function being changed to
	+ * pref_map: if funct==NULL, map to bind to or NULL for new
	+ */
	+static int
	+remap(KEYMAP curmap, int c, PF funct, KEYMAP pref_map)
	+{
	+ int i, n1, n2, nold;
	+ KEYMAP mp, newmap;
	+ PF *pfp;
	+ struct map_element *mep;
	+
	+ if (ele >= &curmap->map_element[curmap->map_num] \|\| c < ele->k_base) {
	+ if (ele > &curmap->map_element[0] && (funct != NULL \|\|
	+ (ele - 1)->k_prefmap == NULL))
	+ n1 = c - (ele - 1)->k_num;
	+ else
	+ n1 = HUGE;
	+ if (ele < &curmap->map_element[curmap->map_num] &&
	+ (funct != NULL \|\| ele->k_prefmap == NULL))
	+ n2 = ele->k_base - c;
	+ else
	+ n2 = HUGE;
	+ if (n1 <= MAPELEDEF && n1 <= n2) {
	+ ele--;
	+ if ((pfp = calloc(c - ele->k_base + 1,
	+ sizeof(PF))) == NULL)
	+ return (dobeep_msg("Out of memory"));
	+
	+ nold = ele->k_num - ele->k_base + 1;
	+ for (i = 0; i < nold; i++)
	+ pfp[i] = ele->k_funcp[i];
	+ while (--n1)
	+ pfp[i++] = curmap->map_default;
	+ pfp[i] = funct;
	+ ele->k_num = c;
	+ ele->k_funcp = pfp;
	+ } else if (n2 <= MAPELEDEF) {
	+ if ((pfp = calloc(ele->k_num - c + 1,
	+ sizeof(PF))) == NULL)
	+ return (dobeep_msg("Out of memory"));
	+
	+ nold = ele->k_num - ele->k_base + 1;
	+ for (i = 0; i < nold; i++)
	+ pfp[i + n2] = ele->k_funcp[i];
	+ while (--n2)
	+ pfp[n2] = curmap->map_default;
	+ pfp[0] = funct;
	+ ele->k_base = c;
	+ ele->k_funcp = pfp;
	+ } else {
	+ if (curmap->map_num >= curmap->map_max) {
	+ if ((newmap = reallocmap(curmap)) == NULL)
	+ return (FALSE);
	+ curmap = newmap;
	+ }
	+ if ((pfp = malloc(sizeof(PF))) == NULL)
	+ return (dobeep_msg("Out of memory"));
	+
	+ pfp[0] = funct;
	+ for (mep = &curmap->map_element[curmap->map_num];
	+ mep > ele; mep--) {
	+ mep->k_base = (mep - 1)->k_base;
	+ mep->k_num = (mep - 1)->k_num;
	+ mep->k_funcp = (mep - 1)->k_funcp;
	+ mep->k_prefmap = (mep - 1)->k_prefmap;
	+ }
	+ ele->k_base = c;
	+ ele->k_num = c;
	+ ele->k_funcp = pfp;
	+ ele->k_prefmap = NULL;
	+ curmap->map_num++;
	+ }
	+ if (funct == NULL) {
	+ if (pref_map != NULL)
	+ ele->k_prefmap = pref_map;
	+ else {
	+ if ((mp = malloc(sizeof(KEYMAP) +
	+ (MAPINIT - 1) * sizeof(struct map_element))) == NULL) {
	+ (void)dobeep_msg("Out of memory");
	+ ele->k_funcp[c - ele->k_base] =
	+ curmap->map_default;
	+ return (FALSE);
	+ }
	+ mp->map_num = 0;
	+ mp->map_max = MAPINIT;
	+ mp->map_default = rescan;
	+ ele->k_prefmap = mp;
	+ }
	+ }
	+ } else {
	+ n1 = c - ele->k_base;
	+ if (ele->k_funcp[n1] == funct && (funct != NULL \|\|
	+ pref_map == NULL \|\| pref_map == ele->k_prefmap))
	+ /* no change */
	+ return (TRUE);
	+ if (funct != NULL \|\| ele->k_prefmap == NULL) {
	+ if (ele->k_funcp[n1] == NULL)
	+ ele->k_prefmap = NULL;
	+ /* easy case */
	+ ele->k_funcp[n1] = funct;
	+ if (funct == NULL) {
	+ if (pref_map != NULL)
	+ ele->k_prefmap = pref_map;
	+ else {
	+ if ((mp = malloc(sizeof(KEYMAP) +
	+ (MAPINIT - 1) *
	+ sizeof(struct map_element))) == NULL) {
	+ (void)dobeep_msg("Out of memory");
	+ ele->k_funcp[c - ele->k_base] =
	+ curmap->map_default;
	+ return (FALSE);
	+ }
	+ mp->map_num = 0;
	+ mp->map_max = MAPINIT;
	+ mp->map_default = rescan;
	+ ele->k_prefmap = mp;
	+ }
	+ }
	+ } else {
	+ /*
	+ * This case is the splits.
	+ * Determine which side of the break c goes on
	+ * 0 = after break; 1 = before break
	+ */
	+ n2 = 1;
	+ for (i = 0; n2 && i < n1; i++)
	+ n2 &= ele->k_funcp[i] != NULL;
	+ if (curmap->map_num >= curmap->map_max) {
	+ if ((newmap = reallocmap(curmap)) == NULL)
	+ return (FALSE);
	+ curmap = newmap;
	+ }
	+ if ((pfp = calloc(ele->k_num - c + !n2,
	+ sizeof(PF))) == NULL)
	+ return (dobeep_msg("Out of memory"));
	+
	+ ele->k_funcp[n1] = NULL;
	+ for (i = n1 + n2; i <= ele->k_num - ele->k_base; i++)
	+ pfp[i - n1 - n2] = ele->k_funcp[i];
	+ for (mep = &curmap->map_element[curmap->map_num];
	+ mep > ele; mep--) {
	+ mep->k_base = (mep - 1)->k_base;
	+ mep->k_num = (mep - 1)->k_num;
	+ mep->k_funcp = (mep - 1)->k_funcp;
	+ mep->k_prefmap = (mep - 1)->k_prefmap;
	+ }
	+ ele->k_num = c - !n2;
	+ (ele + 1)->k_base = c + n2;
	+ (ele + 1)->k_funcp = pfp;
	+ ele += !n2;
	+ ele->k_prefmap = NULL;
	+ curmap->map_num++;
	+ if (pref_map == NULL) {
	+ if ((mp = malloc(sizeof(KEYMAP) + (MAPINIT - 1)
	+ * sizeof(struct map_element))) == NULL) {
	+ (void)dobeep_msg("Out of memory");
	+ ele->k_funcp[c - ele->k_base] =
	+ curmap->map_default;
	+ return (FALSE);
	+ }
	+ mp->map_num = 0;
	+ mp->map_max = MAPINIT;
	+ mp->map_default = rescan;
	+ ele->k_prefmap = mp;
	+ } else
	+ ele->k_prefmap = pref_map;
	+ }
	+ }
	+ return (TRUE);
	+}
	+
	+/*
	+ * Reallocate a keymap. Returns NULL (without trashing the current map)
	+ * on failure.
	+ */
	+static KEYMAP *
	+reallocmap(KEYMAP *curmap)
	+{
	+ struct maps_s *mps;
	+ KEYMAP *mp;
	+ int i;
	+
	+ if (curmap->map_max > SHRT_MAX - MAPGROW) {
	+ (void)dobeep_msg("keymap too large");
	+ return (NULL);
	+ }
	+ if ((mp = malloc(sizeof(KEYMAP) + (curmap->map_max + (MAPGROW - 1)) *
	+ sizeof(struct map_element))) == NULL) {
	+ (void)dobeep_msg("Out of memory");
	+ return (NULL);
	+ }
	+ mp->map_num = curmap->map_num;
	+ mp->map_max = curmap->map_max + MAPGROW;
	+ mp->map_default = curmap->map_default;
	+ for (i = curmap->map_num; i--;) {
	+ mp->map_element[i].k_base = curmap->map_element[i].k_base;
	+ mp->map_element[i].k_num = curmap->map_element[i].k_num;
	+ mp->map_element[i].k_funcp = curmap->map_element[i].k_funcp;
	+ mp->map_element[i].k_prefmap = curmap->map_element[i].k_prefmap;
	+ }
	+ for (mps = maps; mps != NULL; mps = mps->p_next) {
	+ if (mps->p_map == curmap)
	+ mps->p_map = mp;
	+ else
	+ fixmap(curmap, mp, mps->p_map);
	+ }
	+ ele = &mp->map_element[ele - &curmap->map_element[0]];
	+ return (mp);
	+}
	+
	+/*
	+ * Fix references to a reallocated keymap (recursive).
	+ */
	+static void
	+fixmap(KEYMAP curmap, KEYMAP mp, KEYMAP *mt)
	+{
	+ int i;
	+
	+ for (i = mt->map_num; i--;) {
	+ if (mt->map_element[i].k_prefmap != NULL) {
	+ if (mt->map_element[i].k_prefmap == curmap)
	+ mt->map_element[i].k_prefmap = mp;
	+ else
	+ fixmap(curmap, mp, mt->map_element[i].k_prefmap);
	+ }
	+ }
	+}
	+
	+/*
	+ * Do the input for local-set-key, global-set-key and define-key
	+ * then call remap to do the work.
	+ */
	+static int
	+dobind(KEYMAP curmap, const char p, int unbind)
	+{
	+ KEYMAP *pref_map = NULL;
	+ PF funct;
	+ char bprompt[80], bufp, pep;
	+ int c, s, n;
	+
	+ if (macrodef) {
	+ /*
	+ * Keystrokes aren't collected. Not hard, but pretty useless.
	+ * Would not work for function keys in any case.
	+ */
	+ return (dobeep_msg("Can't rebind key in macro"));
	+ }
	+ if (inmacro) {
	+ for (s = 0; s < maclcur->l_used - 1; s++) {
	+ if (doscan(curmap, c = CHARMASK(maclcur->l_text[s]), &curmap)
	+ != NULL) {
	+ if (remap(curmap, c, NULL, NULL)
	+ != TRUE)
	+ return (FALSE);
	+ }
	+ }
	+ (void)doscan(curmap, c = maclcur->l_text[s], NULL);
	+ maclcur = maclcur->l_fp;
	+ } else {
	+ n = strlcpy(bprompt, p, sizeof(bprompt));
	+ if (n >= sizeof(bprompt))
	+ n = sizeof(bprompt) - 1;
	+ pep = bprompt + n;
	+ for (;;) {
	+ ewprintf("%s", bprompt);
	+ pep[-1] = ' ';
	+ pep = getkeyname(pep, sizeof(bprompt) -
	+ (pep - bprompt), c = getkey(FALSE));
	+ if (doscan(curmap, c, &curmap) != NULL)
	+ break;
	+ *pep++ = '-';
	+ *pep = '\0';
	+ }
	+ }
	+ if (unbind)
	+ funct = rescan;
	+ else {
	+ if ((bufp = eread("%s to command: ", bprompt, sizeof(bprompt),
	+ EFFUNC \| EFNEW, bprompt)) == NULL)
	+ return (ABORT);
	+ else if (bufp[0] == '\0')
	+ return (FALSE);
	+ if (((funct = name_function(bprompt)) == NULL) ?
	+ (pref_map = name_map(bprompt)) == NULL : funct == NULL)
	+ return (dobeep_msg("[No match]"));
	+
	+ }
	+ return (remap(curmap, c, funct, pref_map));
	+}
	+
	+/*
	+ * bindkey: bind key sequence to a function in the specified map. Used by
	+ * excline so it can bind function keys. To close to release to change
	+ * calling sequence, should just pass KEYMAP *curmap rather than
	+ * KEYMAP **mapp.
	+ */
	+static int
	+bindkey(KEYMAP *mapp, const char fname, KCHAR *keys, int kcount)
	+{
	+ KEYMAP curmap = mapp;
	+ KEYMAP *pref_map = NULL;
	+ PF funct;
	+ int c;
	+
	+ if (fname == NULL)
	+ funct = rescan;
	+ else if (((funct = name_function(fname)) == NULL) ?
	+ (pref_map = name_map(fname)) == NULL : funct == NULL) {
	+ dobeep();
	+ ewprintf("[No match: %s]", fname);
	+ return (FALSE);
	+ }
	+ while (--kcount) {
	+ if (doscan(curmap, c = *keys++, &curmap) != NULL) {
	+ if (remap(curmap, c, NULL, NULL) != TRUE)
	+ return (FALSE);
	+ /*
	+ * XXX - Bizzarreness. remap creates an empty KEYMAP
	+ * that the last key is supposed to point to.
	+ */
	+ curmap = ele->k_prefmap;
	+ }
	+ }
	+ (void)doscan(curmap, c = *keys, NULL);
	+ return (remap(curmap, c, funct, pref_map));
	+}
	+
	+/*
	+ * Wrapper for bindkey() that converts escapes.
	+ */
	+int
	+dobindkey(KEYMAP map, const char func, const char *str)
	+{
	+ int i;
	+
	+ for (i = 0; *str && i < MAXKEY; i++) {
	+ /* XXX - convert numbers w/ strol()? */
	+ if (str == '^' && (str + 1) != '\0') {
	+ key.k_chars[i] = CCHR(toupper((unsigned char)*++str));
	+ } else if (str == '\\' && (str + 1) != '\0') {
	+ switch (*++str) {
	+ case '^':
	+ key.k_chars[i] = '^';
	+ break;
	+ case 't':
	+ case 'T':
	+ key.k_chars[i] = '\t';
	+ break;
	+ case 'n':
	+ case 'N':
	+ key.k_chars[i] = *curbp->b_nlchr;
	+ break;
	+ case 'r':
	+ case 'R':
	+ key.k_chars[i] = '\r';
	+ break;
	+ case 'e':
	+ case 'E':
	+ key.k_chars[i] = CCHR('[');
	+ break;
	+ case '\\':
	+ key.k_chars[i] = '\\';
	+ break;
	+ }
	+ } else
	+ key.k_chars[i] = *str;
	+ str++;
	+ }
	+ key.k_count = i;
	+ return (bindkey(&map, func, key.k_chars, key.k_count));
	+}
	+
	+/*
	+ * This function modifies the fundamental keyboard map.
	+ */
	+/* ARGSUSED */
	+int
	+bindtokey(int f, int n)
	+{
	+ return (dobind(fundamental_map, "Global set key: ", FALSE));
	+}
	+
	+/*
	+ * This function modifies the current mode's keyboard map.
	+ */
	+/* ARGSUSED */
	+int
	+localbind(int f, int n)
	+{
	+ return (dobind(curbp->b_modes[curbp->b_nmodes]->p_map,
	+ "Local set key: ", FALSE));
	+}
	+
	+/*
	+ * This function redefines a key in any keymap.
	+ */
	+/* ARGSUSED */
	+int
	+redefine_key(int f, int n)
	+{
	+ static char buf[48];
	+ char tmp[32], *bufp;
	+ KEYMAP *mp;
	+
	+ (void)strlcpy(buf, "Define key map: ", sizeof(buf));
	+ if ((bufp = eread("%s", tmp, sizeof(tmp), EFNEW, buf)) == NULL)
	+ return (ABORT);
	+ else if (bufp[0] == '\0')
	+ return (FALSE);
	+ (void)strlcat(buf, tmp, sizeof(buf));
	+ if ((mp = name_map(tmp)) == NULL)
	+ return (dobeep_msgs("Unknown map ", tmp));
	+
	+ if (strlcat(buf, "key: ", sizeof(buf)) >= sizeof(buf))
	+ return (FALSE);
	+
	+ return (dobind(mp, buf, FALSE));
	+}
	+
	+/* ARGSUSED */
	+int
	+unbindtokey(int f, int n)
	+{
	+ return (dobind(fundamental_map, "Global unset key: ", TRUE));
	+}
	+
	+/* ARGSUSED */
	+int
	+localunbind(int f, int n)
	+{
	+ return (dobind(curbp->b_modes[curbp->b_nmodes]->p_map,
	+ "Local unset key: ", TRUE));
	+}
	+
	+/*
	+ * Extended command. Call the message line routine to read in the command
	+ * name and apply autocompletion to it. When it comes back, look the name
	+ * up in the symbol table and run the command if it is found. Print an
	+ * error if there is anything wrong.
	+ */
	+int
	+extend(int f, int n)
	+{
	+ PF funct;
	+ char xname[NXNAME], *bufp;
	+
	+ if (!(f & FFARG))
	+ bufp = eread("M-x ", xname, NXNAME, EFNEW \| EFFUNC);
	+ else
	+ bufp = eread("%d M-x ", xname, NXNAME, EFNEW \| EFFUNC, n);
	+ if (bufp == NULL)
	+ return (ABORT);
	+ else if (bufp[0] == '\0')
	+ return (FALSE);
	+ if ((funct = name_function(bufp)) != NULL) {
	+ if (macrodef) {
	+ struct line *lp = maclcur;
	+ macro[macrocount - 1].m_funct = funct;
	+ maclcur = lp->l_bp;
	+ maclcur->l_fp = lp->l_fp;
	+ free(lp);
	+ }
	+ return ((*funct)(f, n));
	+ }
	+ return (dobeep_msg("[No match]"));
	+}
	+
	+/*
	+ * Define the commands needed to do startup-file processing.
	+ * This code is mostly a kludge just so we can get startup-file processing.
	+ *
	+ * If you're serious about having this code, you should rewrite it.
	+ * To wit:
	+ * It has lots of funny things in it to make the startup-file look
	+ * like a GNU startup file; mostly dealing with parens and semicolons.
	+ * This should all vanish.
	+ *
	+ * We define eval-expression because it's easy. It can make
	+ * *-set-key or define-key set an arbitrary key sequence, so it isn't
	+ * useless.
	+ */
	+
	+/*
	+ * evalexpr - get one line from the user, and run it.
	+ * Use strlen for length of line, assume user is not typing in a '\0' in the
	+ * modeline. llen only used for foundparen() so old-school will be ok.
	+ */
	+/* ARGSUSED */
	+int
	+evalexpr(int f, int n)
	+{
	+ char exbuf[BUFSIZE], *bufp;
	+ int llen;
	+
	+ if ((bufp = eread("Eval: ", exbuf, sizeof(exbuf),
	+ EFNEW \| EFCR)) == NULL)
	+ return (ABORT);
	+ else if (bufp[0] == '\0')
	+ return (FALSE);
	+ llen = strlen(bufp);
	+
	+ return (excline(exbuf, llen, 1));
	+}
	+
	+/*
	+ * evalbuffer - evaluate the current buffer as line commands. Useful for
	+ * testing startup files.
	+ */
	+/* ARGSUSED */
	+int
	+evalbuffer(int f, int n)
	+{
	+ struct line *lp;
	+ struct buffer *bp = curbp;
	+ int s, llen, lnum = 0;
	+ static char excbuf[BUFSIZE];
	+
	+ for (lp = bfirstlp(bp); lp != bp->b_headp; lp = lforw(lp)) {
	+ lnum++;
	+ llen = llength(lp);
	+ if (llen >= BUFSIZE)
	+ return (FALSE);
	+ (void)strncpy(excbuf, ltext(lp), llen);
	+
	+ /* make sure the line is terminated */
	+ excbuf[llen] = '\0';
	+ if ((s = excline(excbuf, llen, lnum)) != TRUE) {
	+ cleanup();
	+ return (s);
	+ }
	+ }
	+ cleanup();
	+ return (TRUE);
	+}
	+
	+/*
	+ * evalfile - go get a file and evaluate it as line commands. You can
	+ * go get your own startup file if need be.
	+ */
	+/* ARGSUSED */
	+int
	+evalfile(int f, int n)
	+{
	+ char fname[NFILEN], *bufp;
	+
	+ if ((bufp = eread("Load file: ", fname, NFILEN,
	+ EFNEW \| EFCR)) == NULL)
	+ return (ABORT);
	+ else if (bufp[0] == '\0')
	+ return (FALSE);
	+ return (load(fname));
	+}
	+
	+/*
	+ * load - go load the file name we got passed.
	+ */
	+int
	+load(const char *fname)
	+{
	+ int s = TRUE, line, ret;
	+ int nbytes = 0;
	+ char excbuf[BUFSIZE], fncpy[NFILEN];
	+ FILE *ffp;
	+
	+ if ((fname = adjustname(fname, TRUE)) == NULL)
	+ /* just to be careful */
	+ return (FALSE);
	+
	+ ret = ffropen(&ffp, fname, NULL);
	+ if (ret != FIOSUC) {
	+ if (ret == FIODIR)
	+ (void)ffclose(ffp, NULL);
	+ return (FALSE);
	+ }
	+
	+ /* keep a note of fname incase of errors in loaded file. */
	+ (void)strlcpy(fncpy, fname, sizeof(fncpy));
	+ line = 0;
	+ while ((s = ffgetline(ffp, excbuf, sizeof(excbuf) - 1, &nbytes))
	+ == FIOSUC) {
	+ line++;
	+ excbuf[nbytes] = '\0';
	+ if (excline(excbuf, nbytes, line) != TRUE) {
	+ s = FIOERR;
	+ dobeep();
	+ ewprintf("Error loading file %s at line %d", fncpy, line);
	+ break;
	+ }
	+ }
	+ (void)ffclose(ffp, NULL);
	+ excbuf[nbytes] = '\0';
	+ if (s != FIOEOF \|\| (nbytes && excline(excbuf, nbytes, ++line) != TRUE))
	+ return (FALSE);
	+ return (TRUE);
	+}
	+
	+/*
	+ * excline - run a line from a load file or eval-expression.
	+ */
	+int
	+excline(char *line, int llen, int lnum)
	+{
	+ PF fp;
	+ struct line lp, np;
	+ int status, c, f, n;
	+ char funcp, tmp;
	+ char *argp = NULL;
	+ long nl;
	+ int bind;
	+ KEYMAP *curmap = NULL;
	+#define BINDARG 0 /* this arg is key to bind (local/global set key) */
	+#define BINDNO 1 /* not binding or non-quoted BINDARG */
	+#define BINDNEXT 2 /* next arg " (define-key) */
	+#define BINDDO 3 /* already found key to bind */
	+#define BINDEXT 1 /* space for trailing \0 */
	+
	+ lp = NULL;
	+
	+ if (macrodef \|\| inmacro)
	+ return (dobeep_msg("Not now!"));
	+
	+ f = 0;
	+ n = 1;
	+ funcp = skipwhite(line);
	+ if (*funcp == '\0')
	+ return (TRUE); /* No error on blank lines */
	+ if (*funcp == '(')
	+ return (foundparen(funcp, llen, lnum));
	+ line = parsetoken(funcp);
	+ if (*line != '\0') {
	+ *line++ = '\0';
	+ line = skipwhite(line);
	+ if (ISDIGIT(line) \|\| line == '-') {
	+ argp = line;
	+ line = parsetoken(line);
	+ }
	+ }
	+ if (argp != NULL) {
	+ f = FFARG;
	+ nl = strtol(argp, &tmp, 10);
	+ if (*tmp != '\0')
	+ return (FALSE);
	+ if (nl >= INT_MAX \|\| nl <= INT_MIN)
	+ return (FALSE);
	+ n = (int)nl;
	+ }
	+ if ((fp = name_function(funcp)) == NULL)
	+ return (dobeep_msgs("Unknown function: ", funcp));
	+
	+ if (fp == bindtokey \|\| fp == unbindtokey) {
	+ bind = BINDARG;
	+ curmap = fundamental_map;
	+ } else if (fp == localbind \|\| fp == localunbind) {
	+ bind = BINDARG;
	+ curmap = curbp->b_modes[curbp->b_nmodes]->p_map;
	+ } else if (fp == redefine_key)
	+ bind = BINDNEXT;
	+ else
	+ bind = BINDNO;
	+ /* Pack away all the args now... */
	+ if ((np = lalloc(0)) == FALSE)
	+ return (FALSE);
	+ np->l_fp = np->l_bp = maclcur = np;
	+ while (*line != '\0') {
	+ argp = skipwhite(line);
	+ if (*argp == '\0')
	+ break;
	+ line = parsetoken(argp);
	+ if (*argp != '"') {
	+ if (*argp == '\'')
	+ ++argp;
	+ if ((lp = lalloc((int) (line - argp) + BINDEXT)) ==
	+ NULL) {
	+ status = FALSE;
	+ goto cleanup;
	+ }
	+ bcopy(argp, ltext(lp), (int)(line - argp));
	+ /* don't count BINDEXT */
	+ lp->l_used--;
	+ if (bind == BINDARG)
	+ bind = BINDNO;
	+ } else {
	+ /* quoted strings are special */
	+ ++argp;
	+ if (bind != BINDARG) {
	+ lp = lalloc((int)(line - argp) + BINDEXT);
	+ if (lp == NULL) {
	+ status = FALSE;
	+ goto cleanup;
	+ }
	+ lp->l_used = 0;
	+ } else
	+ key.k_count = 0;
	+ while (argp != '"' && argp != '\0') {
	+ if (*argp != '\\')
	+ c = *argp++;
	+ else {
	+ switch (*++argp) {
	+ case 't':
	+ case 'T':
	+ c = CCHR('I');
	+ break;
	+ case 'n':
	+ case 'N':
	+ c = CCHR('J');
	+ break;
	+ case 'r':
	+ case 'R':
	+ c = CCHR('M');
	+ break;
	+ case 'e':
	+ case 'E':
	+ c = CCHR('[');
	+ break;
	+ case '^':
	+ /*
	+ * split into two statements
	+ * due to bug in OSK cpp
	+ */
	+ c = CHARMASK(*++argp);
	+ c = ISLOWER(c) ?
	+ CCHR(TOUPPER(c)) : CCHR(c);
	+ break;
	+ case '0':
	+ case '1':
	+ case '2':
	+ case '3':
	+ case '4':
	+ case '5':
	+ case '6':
	+ case '7':
	+ c = *argp - '0';
	+ if (argp[1] <= '7' &&
	+ argp[1] >= '0') {
	+ c <<= 3;
	+ c += *++argp - '0';
	+ if (argp[1] <= '7' &&
	+ argp[1] >= '0') {
	+ c <<= 3;
	+ c += *++argp
	+ - '0';
	+ }
	+ }
	+ break;
	+ case 'f':
	+ case 'F':
	+ c = *++argp - '0';
	+ if (ISDIGIT(argp[1])) {
	+ c *= 10;
	+ c += *++argp - '0';
	+ }
	+ c += KFIRST;
	+ break;
	+ default:
	+ c = CHARMASK(*argp);
	+ break;
	+ }
	+ argp++;
	+ }
	+ if (bind == BINDARG)
	+ key.k_chars[key.k_count++] = c;
	+ else
	+ lp->l_text[lp->l_used++] = c;
	+ }
	+ if (*line)
	+ line++;
	+ }
	+ switch (bind) {
	+ case BINDARG:
	+ bind = BINDDO;
	+ break;
	+ case BINDNEXT:
	+ lp->l_text[lp->l_used] = '\0';
	+ if ((curmap = name_map(lp->l_text)) == NULL) {
	+ (void)dobeep_msgs("No such mode: ", lp->l_text);
	+ status = FALSE;
	+ free(lp);
	+ goto cleanup;
	+ }
	+ free(lp);
	+ bind = BINDARG;
	+ break;
	+ default:
	+ lp->l_fp = np->l_fp;
	+ lp->l_bp = np;
	+ np->l_fp = lp;
	+ np = lp;
	+ }
	+ }
	+ switch (bind) {
	+ default:
	+ (void)dobeep_msg("Bad args to set key");
	+ status = FALSE;
	+ break;
	+ case BINDDO:
	+ if (fp != unbindtokey && fp != localunbind) {
	+ lp->l_text[lp->l_used] = '\0';
	+ status = bindkey(&curmap, lp->l_text, key.k_chars,
	+ key.k_count);
	+ } else
	+ status = bindkey(&curmap, NULL, key.k_chars,
	+ key.k_count);
	+ break;
	+ case BINDNO:
	+ inmacro = TRUE;
	+ maclcur = maclcur->l_fp;
	+ status = (*fp)(f, n);
	+ inmacro = FALSE;
	+ }
	+cleanup:
	+ lp = maclcur->l_fp;
	+ while (lp != maclcur) {
	+ np = lp->l_fp;
	+ free(lp);
	+ lp = np;
	+ }
	+ free(lp);
	+ maclhead = NULL;
	+ macrodef = FALSE;
	+ return (status);
	+}
	+
	+/*
	+ * a pair of utility functions for the above
	+ */
	+char *
	+skipwhite(char *s)
	+{
	+ while (s == ' ' \|\| s == '\t')
	+ s++;
	+ if ((s == ';') \|\| (s == '#'))
	+ *s = '\0';
	+ return (s);
	+}
	+
	+static char *
	+parsetoken(char *s)
	+{
	+ if (*s != '"') {
	+ while (s && s != ' ' && s != '\t' && s != ')' && *s != '(')
	+ s++;
	+ if (*s == ';')
	+ *s = '\0';
	+ } else
	+ do {
	+ /*
	+ * Strings get special treatment.
	+ * Beware: You can \ out the end of the string!
	+ */
	+ if (*s == '\\')
	+ ++s;
	+ } while (++s != '"' && s != '\0');
	+ return (s);
	+}
	Index: contrib/mg/extensions.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/extensions.c
	@@ -0,0 +1,33 @@
	+/*
	+ * This file is in the public domain.
	+ *
	+ * Authors:
	+ * * Brian Callahan
	+ * * Kyle Isom
	+ */
	+
	+#include <sys/queue.h>
	+
	+#include <signal.h>
	+#include <stdio.h>
	+
	+#include "def.h"
	+
	+/*
	+ * Extensions unique to Mg portable.
	+ */
	+
	+int shownlprompt = TRUE;
	+
	+/* Check for a newline at the end of a file? */
	+int
	+togglenewlineprompt(int f, int n)
	+{
	+
	+ if (shownlprompt == TRUE)
	+ shownlprompt = FALSE;
	+ else
	+ shownlprompt = TRUE;
	+
	+ return (TRUE);
	+}
	Index: contrib/mg/file.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/file.c
	@@ -0,0 +1,778 @@
	+/* $OpenBSD: file.c,v 1.102 2019/06/22 15:03:43 lum Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * File commands.
	+ */
	+
	+#include <sys/queue.h>
	+#include <sys/stat.h>
	+#include <errno.h>
	+#include <libgen.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+#include <unistd.h>
	+
	+#include "def.h"
	+
	+size_t xdirname(char , const char , size_t);
	+
	+/*
	+ * Insert a file into the current buffer. Real easy - just call the
	+ * insertfile routine with the file name.
	+ */
	+/* ARGSUSED */
	+int
	+fileinsert(int f, int n)
	+{
	+ char fname[NFILEN], bufp, adjf;
	+
	+ if (getbufcwd(fname, sizeof(fname)) != TRUE)
	+ fname[0] = '\0';
	+ bufp = eread("Insert file: ", fname, NFILEN,
	+ EFNEW \| EFCR \| EFFILE \| EFDEF);
	+ if (bufp == NULL)
	+ return (ABORT);
	+ else if (bufp[0] == '\0')
	+ return (FALSE);
	+ adjf = adjustname(bufp, TRUE);
	+ if (adjf == NULL)
	+ return (FALSE);
	+ return (insertfile(adjf, NULL, FALSE));
	+}
	+
	+/*
	+ * Select a file for editing. If the file is a directory, invoke dired.
	+ * Otherwise, look around to see if you can find the file in another buffer;
	+ * if you can find it, just switch to the buffer. If you cannot find the
	+ * file, create a new buffer, read in the text, and switch to the new buffer.
	+ */
	+/* ARGSUSED */
	+int
	+filevisit(int f, int n)
	+{
	+ struct buffer *bp;
	+ char fname[NFILEN], bufp, adjf;
	+ int status;
	+
	+ if (getbufcwd(fname, sizeof(fname)) != TRUE)
	+ fname[0] = '\0';
	+ bufp = eread("Find file: ", fname, NFILEN,
	+ EFNEW \| EFCR \| EFFILE \| EFDEF);
	+ if (bufp == NULL)
	+ return (ABORT);
	+ else if (bufp[0] == '\0')
	+ return (FALSE);
	+ adjf = adjustname(fname, TRUE);
	+ if (adjf == NULL)
	+ return (FALSE);
	+ if (fisdir(adjf) == TRUE)
	+ return (do_dired(adjf));
	+ if ((bp = findbuffer(adjf)) == NULL)
	+ return (FALSE);
	+ curbp = bp;
	+ if (showbuffer(bp, curwp, WFFULL) != TRUE)
	+ return (FALSE);
	+ if (bp->b_fname[0] == '\0') {
	+ if ((status = readin(adjf)) != TRUE)
	+ killbuffer(bp);
	+ return (status);
	+ }
	+ return (TRUE);
	+}
	+
	+/*
	+ * Replace the current file with an alternate one. Semantics for finding
	+ * the replacement file are the same as 'filevisit', except the current
	+ * buffer is killed before the switch. If the kill fails, or is aborted,
	+ * revert to the original file.
	+ */
	+/* ARGSUSED */
	+int
	+filevisitalt(int f, int n)
	+{
	+ char fname[NFILEN], *bufp;
	+
	+ if (getbufcwd(fname, sizeof(fname)) != TRUE)
	+ fname[0] = '\0';
	+ bufp = eread("Find alternate file: ", fname, NFILEN,
	+ EFNEW \| EFCR \| EFFILE \| EFDEF);
	+ if (bufp == NULL)
	+ return (ABORT);
	+ else if (bufp[0] == '\0')
	+ return (FALSE);
	+
	+ return (do_filevisitalt(fname));
	+}
	+
	+int
	+do_filevisitalt(char *fn)
	+{
	+ struct buffer *bp;
	+ int status;
	+ char *adjf;
	+
	+ status = killbuffer(curbp);
	+ if (status == ABORT \|\| status == FALSE)
	+ return (ABORT);
	+
	+ adjf = adjustname(fn, TRUE);
	+ if (adjf == NULL)
	+ return (FALSE);
	+ if (fisdir(adjf) == TRUE)
	+ return (do_dired(adjf));
	+ if ((bp = findbuffer(adjf)) == NULL)
	+ return (FALSE);
	+ curbp = bp;
	+ if (showbuffer(bp, curwp, WFFULL) != TRUE)
	+ return (FALSE);
	+ if (bp->b_fname[0] == '\0') {
	+ if ((status = readin(adjf)) != TRUE)
	+ killbuffer(bp);
	+ return (status);
	+ }
	+ return (TRUE);
	+}
	+
	+int
	+filevisitro(int f, int n)
	+{
	+ int error;
	+
	+ error = filevisit(f, n);
	+ if (error != TRUE)
	+ return (error);
	+ curbp->b_flag \|= BFREADONLY;
	+ return (TRUE);
	+}
	+
	+/*
	+ * Pop to a file in the other window. Same as the last function, but uses
	+ * popbuf instead of showbuffer.
	+ */
	+/* ARGSUSED */
	+int
	+poptofile(int f, int n)
	+{
	+ struct buffer *bp;
	+ struct mgwin *wp;
	+ char fname[NFILEN], adjf, bufp;
	+ int status;
	+
	+ if (getbufcwd(fname, sizeof(fname)) != TRUE)
	+ fname[0] = '\0';
	+ if ((bufp = eread("Find file in other window: ", fname, NFILEN,
	+ EFNEW \| EFCR \| EFFILE \| EFDEF)) == NULL)
	+ return (ABORT);
	+ else if (bufp[0] == '\0')
	+ return (FALSE);
	+ adjf = adjustname(fname, TRUE);
	+ if (adjf == NULL)
	+ return (FALSE);
	+ if (fisdir(adjf) == TRUE)
	+ return (do_dired(adjf));
	+ if ((bp = findbuffer(adjf)) == NULL)
	+ return (FALSE);
	+ if (bp == curbp)
	+ return (splitwind(f, n));
	+ if ((wp = popbuf(bp, WNONE)) == NULL)
	+ return (FALSE);
	+ curbp = bp;
	+ curwp = wp;
	+ if (bp->b_fname[0] == '\0') {
	+ if ((status = readin(adjf)) != TRUE)
	+ killbuffer(bp);
	+ return (status);
	+ }
	+ return (TRUE);
	+}
	+
	+/*
	+ * Read the file "fname" into the current buffer. Make all of the text
	+ * in the buffer go away, after checking for unsaved changes. This is
	+ * called by the "read" command, the "visit" command, and the mainline
	+ * (for "mg file").
	+ */
	+int
	+readin(char *fname)
	+{
	+ struct mgwin *wp;
	+ struct stat statbuf;
	+ int status, i, ro = FALSE;
	+ PF *ael;
	+ char dp[NFILEN];
	+
	+ /* might be old */
	+ if (bclear(curbp) != TRUE)
	+ return (TRUE);
	+ /* Clear readonly. May be set by autoexec path */
	+ curbp->b_flag &= ~BFREADONLY;
	+ if ((status = insertfile(fname, fname, TRUE)) != TRUE) {
	+ dobeep();
	+ ewprintf("File is not readable: %s", fname);
	+ return (FALSE);
	+ }
	+
	+ for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
	+ if (wp->w_bufp == curbp) {
	+ wp->w_dotp = wp->w_linep = bfirstlp(curbp);
	+ wp->w_doto = 0;
	+ wp->w_markp = NULL;
	+ wp->w_marko = 0;
	+ }
	+ }
	+
	+ /*
	+ * Call auto-executing function if we need to.
	+ */
	+ if ((ael = find_autoexec(fname)) != NULL) {
	+ for (i = 0; ael[i] != NULL; i++)
	+ (*ael[i])(0, 1);
	+ free(ael);
	+ }
	+
	+ /* no change */
	+ curbp->b_flag &= ~BFCHG;
	+
	+ /*
	+ * Set the buffer READONLY flag if any of following are true:
	+ * 1. file is a directory.
	+ * 2. file is read-only.
	+ * 3. file doesn't exist and directory is read-only.
	+ */
	+ if (fisdir(fname) == TRUE) {
	+ ro = TRUE;
	+ } else if ((access(fname, W_OK) == -1)) {
	+ if (errno != ENOENT) {
	+ ro = TRUE;
	+ } else if (errno == ENOENT) {
	+ (void)xdirname(dp, fname, sizeof(dp));
	+ (void)strlcat(dp, "/", sizeof(dp));
	+
	+ /* Missing directory; keep buffer rw, like emacs */
	+ if (stat(dp, &statbuf) == -1 && errno == ENOENT) {
	+ if (eyorn("Missing directory, create") == TRUE)
	+ (void)do_makedir(dp);
	+ } else if (access(dp, W_OK) == -1 && errno == EACCES) {
	+ ewprintf("File not found and directory"
	+ " write-protected");
	+ ro = TRUE;
	+ }
	+ }
	+ }
	+ if (ro == TRUE)
	+ curbp->b_flag \|= BFREADONLY;
	+
	+ if (startrow) {
	+ gotoline(FFARG, startrow);
	+ startrow = 0;
	+ }
	+
	+ undo_add_modified();
	+ return (status);
	+}
	+
	+/*
	+ * NB, getting file attributes is done here under control of a flag
	+ * rather than in readin, which would be cleaner. I was concerned
	+ * that some operating system might require the file to be open
	+ * in order to get the information. Similarly for writing.
	+ */
	+
	+/*
	+ * Insert a file in the current buffer, after dot. If file is a directory,
	+ * and 'replacebuf' is TRUE, invoke dired mode, else die with an error.
	+ * If file is a regular file, set mark at the end of the text inserted;
	+ * point at the beginning. Return a standard status. Print a summary
	+ * (lines read, error message) out as well. This routine also does the
	+ * read end of backup processing. The BFBAK flag, if set in a buffer,
	+ * says that a backup should be taken. It is set when a file is read in,
	+ * but not on a new file. You don't need to make a backup copy of nothing.
	+ */
	+
	+static char *line = NULL;
	+static int linesize = 0;
	+
	+int
	+insertfile(char fname, char newname, int replacebuf)
	+{
	+ struct buffer *bp;
	+ struct line lp1, lp2;
	+ struct line olp; / line we started at */
	+ struct mgwin *wp;
	+ int nbytes, s, nline = 0, siz, x, x2;
	+ int opos; /* offset we started at */
	+ int oline; /* original line number */
	+ FILE *ffp;
	+
	+ if (replacebuf == TRUE)
	+ x = undo_enable(FFRAND, 0);
	+ else
	+ x = undo_enabled();
	+
	+ lp1 = NULL;
	+ if (line == NULL) {
	+ line = malloc(NLINE);
	+ if (line == NULL)
	+ panic("out of memory");
	+ linesize = NLINE;
	+ }
	+
	+ /* cheap */
	+ bp = curbp;
	+ if (newname != NULL) {
	+ (void)strlcpy(bp->b_fname, newname, sizeof(bp->b_fname));
	+ (void)xdirname(bp->b_cwd, newname, sizeof(bp->b_cwd));
	+ (void)strlcat(bp->b_cwd, "/", sizeof(bp->b_cwd));
	+ }
	+
	+ /* hard file open */
	+ if ((s = ffropen(&ffp, fname, (replacebuf == TRUE) ? bp : NULL))
	+ == FIOERR)
	+ goto out;
	+ if (s == FIOFNF) {
	+ /* file not found */
	+ if (newname != NULL)
	+ ewprintf("(New file)");
	+ else
	+ ewprintf("(File not found)");
	+ goto out;
	+ } else if (s == FIODIR) {
	+ /* file was a directory */
	+ if (replacebuf == FALSE) {
	+ dobeep();
	+ ewprintf("Cannot insert: file is a directory, %s",
	+ fname);
	+ goto cleanup;
	+ }
	+ killbuffer(bp);
	+ bp = dired_(fname);
	+ undo_enable(FFRAND, x);
	+ if (bp == NULL)
	+ return (FALSE);
	+ curbp = bp;
	+ return (showbuffer(bp, curwp, WFFULL \| WFMODE));
	+ } else {
	+ (void)xdirname(bp->b_cwd, fname, sizeof(bp->b_cwd));
	+ (void)strlcat(bp->b_cwd, "/", sizeof(bp->b_cwd));
	+ }
	+ opos = curwp->w_doto;
	+ oline = curwp->w_dotline;
	+ /*
	+ * Open a new line at dot and start inserting after it.
	+ * We will delete this newline after insertion.
	+ * Disable undo, as we create the undo record manually.
	+ */
	+ x2 = undo_enable(FFRAND, 0);
	+ (void)lnewline();
	+ olp = lback(curwp->w_dotp);
	+ undo_enable(FFRAND, x2);
	+
	+ nline = 0;
	+ siz = 0;
	+ while ((s = ffgetline(ffp, line, linesize, &nbytes)) != FIOERR) {
	+retry:
	+ siz += nbytes + 1;
	+ switch (s) {
	+ case FIOSUC:
	+ /* FALLTHRU */
	+ case FIOEOF:
	+ ++nline;
	+ if ((lp1 = lalloc(nbytes)) == NULL) {
	+ /* keep message on the display */
	+ s = FIOERR;
	+ undo_add_insert(olp, opos,
	+ siz - nbytes - 1 - 1);
	+ goto endoffile;
	+ }
	+ bcopy(line, &ltext(lp1)[0], nbytes);
	+ lp2 = lback(curwp->w_dotp);
	+ lp2->l_fp = lp1;
	+ lp1->l_fp = curwp->w_dotp;
	+ lp1->l_bp = lp2;
	+ curwp->w_dotp->l_bp = lp1;
	+ if (s == FIOEOF) {
	+ undo_add_insert(olp, opos, siz - 1);
	+ goto endoffile;
	+ }
	+ break;
	+ case FIOLONG: {
	+ /* a line too long to fit in our buffer */
	+ char *cp;
	+ int newsize;
	+
	+ newsize = linesize * 2;
	+ if (newsize < 0 \|\|
	+ (cp = malloc(newsize)) == NULL) {
	+ dobeep();
	+ ewprintf("Could not allocate %d bytes",
	+ newsize);
	+ s = FIOERR;
	+ goto endoffile;
	+ }
	+ bcopy(line, cp, linesize);
	+ free(line);
	+ line = cp;
	+ s = ffgetline(ffp, line + linesize, linesize,
	+ &nbytes);
	+ nbytes += linesize;
	+ linesize = newsize;
	+ if (s == FIOERR)
	+ goto endoffile;
	+ goto retry;
	+ }
	+ default:
	+ dobeep();
	+ ewprintf("Unknown code %d reading file", s);
	+ s = FIOERR;
	+ break;
	+ }
	+ }
	+endoffile:
	+ /* ignore errors */
	+ (void)ffclose(ffp, NULL);
	+ /* don't zap an error */
	+ if (s == FIOEOF) {
	+ if (nline == 1)
	+ ewprintf("(Read 1 line)");
	+ else
	+ ewprintf("(Read %d lines)", nline);
	+ }
	+ /* set mark at the end of the text */
	+ curwp->w_dotp = curwp->w_markp = lback(curwp->w_dotp);
	+ curwp->w_marko = llength(curwp->w_markp);
	+ curwp->w_markline = oline + nline + 1;
	+ /*
	+ * if we are at the end of the file, ldelnewline is a no-op,
	+ * but we still need to decrement the line and markline counts
	+ * as we've accounted for this fencepost in our arithmetic
	+ */
	+ if (lforw(curwp->w_dotp) == curwp->w_bufp->b_headp) {
	+ curwp->w_bufp->b_lines--;
	+ curwp->w_markline--;
	+ } else
	+ (void)ldelnewline();
	+ curwp->w_dotp = olp;
	+ curwp->w_doto = opos;
	+ curwp->w_dotline = oline;
	+ if (olp == curbp->b_headp)
	+ curwp->w_dotp = lforw(olp);
	+ if (newname != NULL)
	+ bp->b_flag \|= BFCHG \| BFBAK; /* Need a backup. */
	+ else
	+ bp->b_flag \|= BFCHG;
	+ /*
	+ * If the insert was at the end of buffer, set lp1 to the end of
	+ * buffer line, and lp2 to the beginning of the newly inserted text.
	+ * (Otherwise lp2 is set to NULL.) This is used below to set
	+ * pointers in other windows correctly if they are also at the end of
	+ * buffer.
	+ */
	+ lp1 = bp->b_headp;
	+ if (curwp->w_markp == lp1) {
	+ lp2 = curwp->w_dotp;
	+ } else {
	+ /* delete extraneous newline */
	+ (void)ldelnewline();
	+out: lp2 = NULL;
	+ }
	+ for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
	+ if (wp->w_bufp == curbp) {
	+ wp->w_rflag \|= WFMODE \| WFEDIT;
	+ if (wp != curwp && lp2 != NULL) {
	+ if (wp->w_dotp == lp1)
	+ wp->w_dotp = lp2;
	+ if (wp->w_markp == lp1)
	+ wp->w_markp = lp2;
	+ if (wp->w_linep == lp1)
	+ wp->w_linep = lp2;
	+ }
	+ }
	+ }
	+ bp->b_lines += nline;
	+cleanup:
	+ undo_enable(FFRAND, x);
	+
	+ /* return FALSE if error */
	+ return (s != FIOERR);
	+}
	+
	+/*
	+ * Ask for a file name and write the contents of the current buffer to that
	+ * file. Update the remembered file name and clear the buffer changed flag.
	+ * This handling of file names is different from the earlier versions and
	+ * is more compatible with Gosling EMACS than with ITS EMACS.
	+ */
	+/* ARGSUSED */
	+int
	+filewrite(int f, int n)
	+{
	+ struct stat statbuf;
	+ int s;
	+ char fname[NFILEN], bn[NBUFN], tmp[NFILEN + 25];
	+ char adjfname, bufp;
	+ FILE *ffp;
	+
	+ if (getbufcwd(fname, sizeof(fname)) != TRUE)
	+ fname[0] = '\0';
	+ if ((bufp = eread("Write file: ", fname, NFILEN,
	+ EFDEF \| EFNEW \| EFCR \| EFFILE)) == NULL)
	+ return (ABORT);
	+ else if (bufp[0] == '\0')
	+ return (FALSE);
	+
	+ adjfname = adjustname(fname, TRUE);
	+ if (adjfname == NULL)
	+ return (FALSE);
	+
	+ /* Check if file exists; write checks done later */
	+ if (stat(adjfname, &statbuf) == 0) {
	+ if (S_ISDIR(statbuf.st_mode)) {
	+ dobeep();
	+ ewprintf("%s is a directory", adjfname);
	+ return (FALSE);
	+ }
	+ snprintf(tmp, sizeof(tmp), "File `%s' exists; overwrite",
	+ adjfname);
	+ if ((s = eyorn(tmp)) != TRUE)
	+ return (s);
	+ }
	+
	+ /* old attributes are no longer current */
	+ bzero(&curbp->b_fi, sizeof(curbp->b_fi));
	+ if ((s = writeout(&ffp, curbp, adjfname)) == TRUE) {
	+ (void)strlcpy(curbp->b_fname, adjfname, sizeof(curbp->b_fname));
	+ if (getbufcwd(curbp->b_cwd, sizeof(curbp->b_cwd)) != TRUE)
	+ (void)strlcpy(curbp->b_cwd, "/", sizeof(curbp->b_cwd));
	+ if (augbname(bn, curbp->b_fname, sizeof(bn))
	+ == FALSE)
	+ return (FALSE);
	+ free(curbp->b_bname);
	+ if ((curbp->b_bname = strdup(bn)) == NULL)
	+ return (FALSE);
	+ (void)fupdstat(curbp);
	+ curbp->b_flag &= ~(BFBAK \| BFCHG);
	+ upmodes(curbp);
	+ undo_add_boundary(FFRAND, 1);
	+ undo_add_modified();
	+ }
	+ return (s);
	+}
	+
	+/*
	+ * Save the contents of the current buffer back into its associated file.
	+ */
	+static int makebackup = TRUE;
	+
	+/* ARGSUSED */
	+int
	+filesave(int f, int n)
	+{
	+ if (curbp->b_fname[0] == '\0')
	+ return (filewrite(f, n));
	+ else
	+ return (buffsave(curbp));
	+}
	+
	+/*
	+ * Save the contents of the buffer argument into its associated file. Do
	+ * nothing if there have been no changes (is this a bug, or a feature?).
	+ * Error if there is no remembered file name. If this is the first write
	+ * since the read or visit, then a backup copy of the file is made.
	+ * Allow user to select whether or not to make backup files by looking at
	+ * the value of makebackup.
	+ */
	+int
	+buffsave(struct buffer *bp)
	+{
	+ int s;
	+ FILE *ffp;
	+
	+ /* return, no changes */
	+ if ((bp->b_flag & BFCHG) == 0) {
	+ ewprintf("(No changes need to be saved)");
	+ return (TRUE);
	+ }
	+
	+ /* must have a name */
	+ if (bp->b_fname[0] == '\0') {
	+ dobeep();
	+ ewprintf("No file name");
	+ return (FALSE);
	+ }
	+
	+ /* Ensure file has not been modified elsewhere */
	+ /* We don't use the ignore flag here */
	+ if (fchecktime(bp) != TRUE) {
	+ if ((s = eyesno("File has changed on disk since last save. "
	+ "Save anyway")) != TRUE)
	+ return (s);
	+ }
	+
	+ if (makebackup && (bp->b_flag & BFBAK)) {
	+ s = fbackupfile(bp->b_fname);
	+ /* hard error */
	+ if (s == ABORT)
	+ return (FALSE);
	+ /* softer error */
	+ if (s == FALSE &&
	+ (s = eyesno("Backup error, save anyway")) != TRUE)
	+ return (s);
	+ }
	+ if ((s = writeout(&ffp, bp, bp->b_fname)) == TRUE) {
	+ (void)fupdstat(bp);
	+ bp->b_flag &= ~(BFCHG \| BFBAK);
	+ upmodes(bp);
	+ undo_add_boundary(FFRAND, 1);
	+ undo_add_modified();
	+ }
	+ return (s);
	+}
	+
	+/*
	+ * Since we don't have variables (we probably should) this is a command
	+ * processor for changing the value of the make backup flag. If no argument
	+ * is given, sets makebackup to true, so backups are made. If an argument is
	+ * given, no backup files are made when saving a new version of a file.
	+ */
	+/* ARGSUSED */
	+int
	+makebkfile(int f, int n)
	+{
	+ if (f & FFARG)
	+ makebackup = n > 0;
	+ else
	+ makebackup = !makebackup;
	+ ewprintf("Backup files %sabled", makebackup ? "en" : "dis");
	+ return (TRUE);
	+}
	+
	+/*
	+ * NB: bp is passed to both ffwopen and ffclose because some
	+ * attribute information may need to be updated at open time
	+ * and others after the close. This is OS-dependent. Note
	+ * that the ff routines are assumed to be able to tell whether
	+ * the attribute information has been set up in this buffer
	+ * or not.
	+ */
	+
	+/*
	+ * This function performs the details of file writing; writing the file
	+ * in buffer bp to file fn. Uses the file management routines in the
	+ * "fileio.c" package. Most of the grief is checking of some sort.
	+ * You may want to call fupdstat() after using this function.
	+ */
	+int
	+writeout(FILE ** ffp, struct buffer bp, char fn)
	+{
	+ struct stat statbuf;
	+ struct line *lpend;
	+ int s, eobnl;
	+ char dp[NFILEN];
	+
	+ if (stat(fn, &statbuf) == -1 && errno == ENOENT) {
	+ errno = 0;
	+ (void)xdirname(dp, fn, sizeof(dp));
	+ (void)strlcat(dp, "/", sizeof(dp));
	+ if (access(dp, W_OK) && errno == EACCES) {
	+ dobeep();
	+ ewprintf("Directory %s write-protected", dp);
	+ return (FIOERR);
	+ } else if (errno == ENOENT) {
	+ dobeep();
	+ ewprintf("%s: no such directory", dp);
	+ return (FIOERR);
	+ }
	+ }
	+ lpend = bp->b_headp;
	+ eobnl = 0;
	+ if (llength(lback(lpend)) != 0) {
	+ eobnl = eyorn("No newline at end of file, add one");
	+ if (eobnl != TRUE && eobnl != FALSE)
	+ return (eobnl); /* abort */
	+ }
	+ /* open writes message */
	+ if ((s = ffwopen(ffp, fn, bp)) != FIOSUC)
	+ return (FALSE);
	+ s = ffputbuf(*ffp, bp, eobnl);
	+ if (s == FIOSUC) {
	+ /* no write error */
	+ s = ffclose(*ffp, bp);
	+ if (s == FIOSUC)
	+ ewprintf("Wrote %s", fn);
	+ } else {
	+ /* print a message indicating write error */
	+ (void)ffclose(*ffp, bp);
	+ dobeep();
	+ ewprintf("Unable to write %s", fn);
	+ }
	+ return (s == FIOSUC);
	+}
	+
	+/*
	+ * Tag all windows for bp (all windows if bp == NULL) as needing their
	+ * mode line updated.
	+ */
	+void
	+upmodes(struct buffer *bp)
	+{
	+ struct mgwin *wp;
	+
	+ for (wp = wheadp; wp != NULL; wp = wp->w_wndp)
	+ if (bp == NULL \|\| curwp->w_bufp == bp)
	+ wp->w_rflag \|= WFMODE;
	+}
	+
	+/*
	+ * dirname using strlcpy semantic.
	+ * Like dirname() except an empty string is returned in
	+ * place of "/". This means we can always add a trailing
	+ * slash and be correct.
	+ * Address portability issues by copying argument
	+ * before using. Some implementations modify the input string.
	+ */
	+size_t
	+xdirname(char dp, const char path, size_t dplen)
	+{
	+ char ts[NFILEN];
	+ size_t len;
	+
	+ (void)strlcpy(ts, path, NFILEN);
	+ len = strlcpy(dp, dirname(ts), dplen);
	+ if (dplen > 0 && dp[0] == '/' && dp[1] == '\0') {
	+ dp[0] = '\0';
	+ len = 0;
	+ }
	+ return (len);
	+}
	+
	+/*
	+ * basename using strlcpy/strlcat semantic.
	+ * Address portability issue by copying argument
	+ * before using: some implementations modify the input string.
	+ */
	+size_t
	+xbasename(char bp, const char path, size_t bplen)
	+{
	+ char ts[NFILEN];
	+
	+ (void)strlcpy(ts, path, NFILEN);
	+ return (strlcpy(bp, basename(ts), bplen));
	+}
	+
	+/*
	+ * The adjusted file name refers to a directory, so open dired mode.
	+ */
	+int
	+do_dired(char *adjf)
	+{
	+ struct buffer *bp;
	+
	+ if ((bp = dired_(adjf)) == FALSE)
	+ return (FALSE);
	+ curbp = bp;
	+ return (showbuffer(bp, curwp, WFFULL \| WFMODE));
	+}
	Index: contrib/mg/fileio.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/fileio.c
	@@ -0,0 +1,752 @@
	+/* $OpenBSD: fileio.c,v 1.108 2021/03/01 10:51:14 lum Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * POSIX fileio.c
	+ */
	+
	+#include <sys/queue.h>
	+#include <sys/resource.h>
	+#include <sys/stat.h>
	+#include <sys/time.h>
	+#include <sys/types.h>
	+#include <sys/wait.h>
	+#include <dirent.h>
	+#include <errno.h>
	+#include <fcntl.h>
	+#include <limits.h>
	+#include <pwd.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+#include <unistd.h>
	+
	+#include "def.h"
	+#include "kbd.h"
	+#include "pathnames.h"
	+
	+static char bkuplocation(const char );
	+static int bkupleavetmp(const char *);
	+
	+static char *bkupdir;
	+static int leavetmp = 0; /* 1 = leave any '~' files in tmp dir */
	+
	+/*
	+ * Open a file for reading.
	+ */
	+int
	+ffropen(FILE ** ffp, const char fn, struct buffer bp)
	+{
	+ if ((*ffp = fopen(fn, "r")) == NULL) {
	+ if (errno == ENOENT)
	+ return (FIOFNF);
	+ return (FIOERR);
	+ }
	+
	+ /* If 'fn' is a directory open it with dired. */
	+ if (fisdir(fn) == TRUE)
	+ return (FIODIR);
	+
	+ ffstat(*ffp, bp);
	+
	+ return (FIOSUC);
	+}
	+
	+/*
	+ * Update stat/dirty info
	+ */
	+void
	+ffstat(FILE ffp, struct buffer bp)
	+{
	+ struct stat sb;
	+
	+ if (bp && fstat(fileno(ffp), &sb) == 0) {
	+ /* set highorder bit to make sure this isn't all zero */
	+ bp->b_fi.fi_mode = sb.st_mode \| 0x8000;
	+ bp->b_fi.fi_uid = sb.st_uid;
	+ bp->b_fi.fi_gid = sb.st_gid;
	+ bp->b_fi.fi_mtime = sb.st_mtimespec;
	+ /* Clear the ignore flag */
	+ bp->b_flag &= ~(BFIGNDIRTY \| BFDIRTY);
	+ }
	+}
	+
	+/*
	+ * Update the status/dirty info. If there is an error,
	+ * there's not a lot we can do.
	+ */
	+int
	+fupdstat(struct buffer *bp)
	+{
	+ FILE *ffp;
	+
	+ if ((ffp = fopen(bp->b_fname, "r")) == NULL) {
	+ if (errno == ENOENT)
	+ return (FIOFNF);
	+ return (FIOERR);
	+ }
	+ ffstat(ffp, bp);
	+ (void)ffclose(ffp, bp);
	+ return (FIOSUC);
	+}
	+
	+/*
	+ * Open a file for writing.
	+ */
	+int
	+ffwopen(FILE ** ffp, const char fn, struct buffer bp)
	+{
	+ int fd;
	+ mode_t fmode = DEFFILEMODE;
	+
	+ if (bp && bp->b_fi.fi_mode)
	+ fmode = bp->b_fi.fi_mode & 07777;
	+
	+ fd = open(fn, O_RDWR \| O_CREAT \| O_TRUNC, fmode);
	+ if (fd == -1) {
	+ ffp = NULL;
	+ dobeep();
	+ ewprintf("Cannot open file for writing : %s", strerror(errno));
	+ return (FIOERR);
	+ }
	+
	+ if ((*ffp = fdopen(fd, "w")) == NULL) {
	+ dobeep();
	+ ewprintf("Cannot open file for writing : %s", strerror(errno));
	+ close(fd);
	+ return (FIOERR);
	+ }
	+
	+ /*
	+ * If we have file information, use it. We don't bother to check for
	+ * errors, because there's no a lot we can do about it. Certainly
	+ * trying to change ownership will fail if we aren't root. That's
	+ * probably OK. If we don't have info, no need to get it, since any
	+ * future writes will do the same thing.
	+ */
	+ if (bp && bp->b_fi.fi_mode) {
	+ fchmod(fd, bp->b_fi.fi_mode & 07777);
	+ fchown(fd, bp->b_fi.fi_uid, bp->b_fi.fi_gid);
	+ }
	+ return (FIOSUC);
	+}
	+
	+/*
	+ * Close a file.
	+ */
	+/* ARGSUSED */
	+int
	+ffclose(FILE ffp, struct buffer bp)
	+{
	+ if (fclose(ffp) == 0)
	+ return (FIOSUC);
	+ return (FIOERR);
	+}
	+
	+/*
	+ * Write a buffer to the already opened file. bp points to the
	+ * buffer. Return the status.
	+ */
	+int
	+ffputbuf(FILE ffp, struct buffer bp, int eobnl)
	+{
	+ struct line lp, lpend;
	+
	+ lpend = bp->b_headp;
	+
	+ for (lp = lforw(lpend); lp != lpend; lp = lforw(lp)) {
	+ if (fwrite(ltext(lp), 1, llength(lp), ffp) != llength(lp)) {
	+ dobeep();
	+ ewprintf("Write I/O error");
	+ return (FIOERR);
	+ }
	+ if (lforw(lp) != lpend) /* no implied \n on last line */
	+ putc(*bp->b_nlchr, ffp);
	+ }
	+ if (eobnl) {
	+ lnewline_at(lback(lpend), llength(lback(lpend)));
	+ putc(*bp->b_nlchr, ffp);
	+ }
	+ return (FIOSUC);
	+}
	+
	+/*
	+ * Read a line from a file, and store the bytes
	+ * in the supplied buffer. Stop on end of file or end of
	+ * line. When FIOEOF is returned, there is a valid line
	+ * of data without the normally implied \n.
	+ * If the line length exceeds nbuf, FIOLONG is returned.
	+ */
	+int
	+ffgetline(FILE ffp, char buf, int nbuf, int *nbytes)
	+{
	+ int c, i;
	+
	+ i = 0;
	+ while ((c = getc(ffp)) != EOF && c != *curbp->b_nlchr) {
	+ buf[i++] = c;
	+ if (i >= nbuf)
	+ return (FIOLONG);
	+ }
	+ if (c == EOF && ferror(ffp) != FALSE) {
	+ dobeep();
	+ ewprintf("File read error");
	+ return (FIOERR);
	+ }
	+ *nbytes = i;
	+ return (c == EOF ? FIOEOF : FIOSUC);
	+}
	+
	+/*
	+ * Make a backup copy of "fname". On Unix the backup has the same
	+ * name as the original file, with a "~" on the end; this seems to
	+ * be newest of the new-speak. The error handling is all in "file.c".
	+ * We do a copy instead of a rename since otherwise another process
	+ * with an open fd will get the backup, not the new file. This is
	+ * a problem when using mg with things like crontab and vipw.
	+ */
	+int
	+fbackupfile(const char *fn)
	+{
	+ struct stat sb;
	+ struct timespec new_times[2];
	+ int from, to, serrno;
	+ ssize_t nread;
	+ char buf[BUFSIZ];
	+ char nname, tname, *bkpth;
	+
	+ if (stat(fn, &sb) == -1) {
	+ dobeep();
	+ ewprintf("Can't stat %s : %s", fn, strerror(errno));
	+ return (FALSE);
	+ }
	+
	+ if ((bkpth = bkuplocation(fn)) == NULL)
	+ return (FALSE);
	+
	+ if (asprintf(&nname, "%s~", bkpth) == -1) {
	+ dobeep();
	+ ewprintf("Can't allocate backup file name : %s", strerror(errno));
	+ free(bkpth);
	+ return (ABORT);
	+ }
	+ if (asprintf(&tname, "%s.XXXXXXXXXX", bkpth) == -1) {
	+ dobeep();
	+ ewprintf("Can't allocate temp file name : %s", strerror(errno));
	+ free(bkpth);
	+ free(nname);
	+ return (ABORT);
	+ }
	+ free(bkpth);
	+
	+ if ((from = open(fn, O_RDONLY)) == -1) {
	+ free(nname);
	+ free(tname);
	+ return (FALSE);
	+ }
	+ to = mkstemp(tname);
	+ if (to == -1) {
	+ serrno = errno;
	+ close(from);
	+ free(nname);
	+ free(tname);
	+ errno = serrno;
	+ return (FALSE);
	+ }
	+ while ((nread = read(from, buf, sizeof(buf))) > 0) {
	+ if (write(to, buf, (size_t)nread) != nread) {
	+ nread = -1;
	+ break;
	+ }
	+ }
	+ serrno = errno;
	+ (void) fchmod(to, (sb.st_mode & 0777));
	+
	+ /* copy the mtime to the backupfile */
	+ new_times[0] = sb.st_atim;
	+ new_times[1] = sb.st_mtim;
	+ futimens(to, new_times);
	+
	+ close(from);
	+ close(to);
	+ if (nread == -1) {
	+ if (unlink(tname) == -1)
	+ ewprintf("Can't unlink temp : %s", strerror(errno));
	+ } else {
	+ if (rename(tname, nname) == -1) {
	+ ewprintf("Can't rename temp : %s", strerror(errno));
	+ (void) unlink(tname);
	+ nread = -1;
	+ }
	+ }
	+ free(nname);
	+ free(tname);
	+ errno = serrno;
	+
	+ return (nread == -1 ? FALSE : TRUE);
	+}
	+
	+/*
	+ * Convert "fn" to a canonicalized absolute filename, replacing
	+ * a leading ~/ with the user's home dir, following symlinks, and
	+ * remove all occurrences of /./ and /../
	+ */
	+char *
	+adjustname(const char *fn, int slashslash)
	+{
	+ static char fnb[PATH_MAX];
	+ const char cp, ep = NULL;
	+ char *path;
	+
	+ if (slashslash == TRUE) {
	+ cp = fn + strlen(fn) - 1;
	+ for (; cp >= fn; cp--) {
	+ if (ep && (*cp == '/')) {
	+ fn = ep;
	+ break;
	+ }
	+ if (cp == '/' \|\| cp == '~')
	+ ep = cp;
	+ else
	+ ep = NULL;
	+ }
	+ }
	+ if ((path = expandtilde(fn)) == NULL)
	+ return (NULL);
	+
	+ if (realpath(path, fnb) == NULL)
	+ (void)strlcpy(fnb, path, sizeof(fnb));
	+
	+ free(path);
	+ return (fnb);
	+}
	+
	+/*
	+ * Find a startup file for the user and return its name. As a service
	+ * to other pieces of code that may want to find a startup file (like
	+ * the terminal driver in particular), accepts a suffix to be appended
	+ * to the startup file name.
	+ */
	+char *
	+startupfile(char suffix, char conffile)
	+{
	+ static char file[NFILEN];
	+ char *home;
	+ int ret;
	+
	+ if ((home = getenv("HOME")) == NULL \|\| *home == '\0')
	+ goto nohome;
	+
	+ if (conffile != NULL) {
	+ (void)strncpy(file, conffile, NFILEN);
	+ } else if (suffix == NULL) {
	+ ret = snprintf(file, sizeof(file), _PATH_MG_STARTUP, home);
	+ if (ret < 0 \|\| ret >= sizeof(file))
	+ return (NULL);
	+ } else {
	+ ret = snprintf(file, sizeof(file), _PATH_MG_TERM, home, suffix);
	+ if (ret < 0 \|\| ret >= sizeof(file))
	+ return (NULL);
	+ }
	+
	+ if (access(file, R_OK) == 0)
	+ return (file);
	+nohome:
	+#ifdef STARTUPFILE
	+ if (suffix == NULL) {
	+ ret = snprintf(file, sizeof(file), "%s", STARTUPFILE);
	+ if (ret < 0 \|\| ret >= sizeof(file))
	+ return (NULL);
	+ } else {
	+ ret = snprintf(file, sizeof(file), "%s%s", STARTUPFILE,
	+ suffix);
	+ if (ret < 0 \|\| ret >= sizeof(file))
	+ return (NULL);
	+ }
	+
	+ if (access(file, R_OK) == 0)
	+ return (file);
	+#endif /* STARTUPFILE */
	+ return (NULL);
	+}
	+
	+int
	+copy(char frname, char toname)
	+{
	+ int ifd, ofd;
	+ char buf[BUFSIZ];
	+ mode_t fmode = DEFFILEMODE; /* XXX?? */
	+ struct stat orig;
	+ ssize_t sr;
	+
	+ if ((ifd = open(frname, O_RDONLY)) == -1)
	+ return (FALSE);
	+ if (fstat(ifd, &orig) == -1) {
	+ dobeep();
	+ ewprintf("fstat: %s", strerror(errno));
	+ close(ifd);
	+ return (FALSE);
	+ }
	+
	+ if ((ofd = open(toname, O_WRONLY\|O_CREAT\|O_TRUNC, fmode)) == -1) {
	+ close(ifd);
	+ return (FALSE);
	+ }
	+ while ((sr = read(ifd, buf, sizeof(buf))) > 0) {
	+ if (write(ofd, buf, (size_t)sr) != sr) {
	+ ewprintf("write error : %s", strerror(errno));
	+ break;
	+ }
	+ }
	+ if (fchmod(ofd, orig.st_mode) == -1)
	+ ewprintf("Cannot set original mode : %s", strerror(errno));
	+
	+ if (sr == -1) {
	+ ewprintf("Read error : %s", strerror(errno));
	+ close(ifd);
	+ close(ofd);
	+ return (FALSE);
	+ }
	+ /*
	+ * It is "normal" for this to fail since we can't guarantee that
	+ * we will be running as root.
	+ */
	+ if (fchown(ofd, orig.st_uid, orig.st_gid) && errno != EPERM)
	+ ewprintf("Cannot set owner : %s", strerror(errno));
	+
	+ (void) close(ifd);
	+ (void) close(ofd);
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * return list of file names that match the name in buf.
	+ */
	+struct list *
	+make_file_list(char *buf)
	+{
	+ char dir, file, *cp;
	+ size_t len, preflen;
	+ int ret;
	+ DIR *dirp;
	+ struct dirent *dent;
	+ struct list last, current;
	+ char fl_name[NFILEN + 2];
	+ char prefixx[NFILEN + 1];
	+
	+ /*
	+ * We need three different strings:
	+
	+ * dir - the name of the directory containing what the user typed.
	+ * Must be a real unix file name, e.g. no ~user, etc..
	+ * Must not end in /.
	+ * prefix - the portion of what the user typed that is before the
	+ * names we are going to find in the directory. Must have a
	+ * trailing / if the user typed it.
	+ * names from the directory - We open dir, and return prefix
	+ * concatenated with names.
	+ */
	+
	+ /* first we get a directory name we can look up */
	+ /*
	+ * Names ending in . are potentially odd, because adjustname will
	+ * treat foo/bar/.. as a foo/, whereas we are
	+ * interested in names starting with ..
	+ */
	+ len = strlen(buf);
	+ if (len && buf[len - 1] == '.') {
	+ buf[len - 1] = 'x';
	+ dir = adjustname(buf, TRUE);
	+ buf[len - 1] = '.';
	+ } else
	+ dir = adjustname(buf, TRUE);
	+ if (dir == NULL)
	+ return (NULL);
	+ /*
	+ * If the user typed a trailing / or the empty string
	+ * he wants us to use his file spec as a directory name.
	+ */
	+ if (len && buf[len - 1] != '/') {
	+ file = strrchr(dir, '/');
	+ if (file) {
	+ *file = '\0';
	+ if (*dir == '\0')
	+ dir = "/";
	+ } else
	+ return (NULL);
	+ }
	+ /* Now we get the prefix of the name the user typed. */
	+ if (strlcpy(prefixx, buf, sizeof(prefixx)) >= sizeof(prefixx))
	+ return (NULL);
	+ cp = strrchr(prefixx, '/');
	+ if (cp == NULL)
	+ prefixx[0] = '\0';
	+ else
	+ cp[1] = '\0';
	+
	+ preflen = strlen(prefixx);
	+ /* cp is the tail of buf that really needs to be compared. */
	+ cp = buf + preflen;
	+ len = strlen(cp);
	+
	+ /*
	+ * Now make sure that file names will fit in the buffers allocated.
	+ * SV files are fairly short. For BSD, something more general would
	+ * be required.
	+ */
	+ if (preflen > NFILEN - NAME_MAX)
	+ return (NULL);
	+
	+ /* loop over the specified directory, making up the list of files */
	+
	+ /*
	+ * Note that it is worth our time to filter out names that don't
	+ * match, even though our caller is going to do so again, and to
	+ * avoid doing the stat if completion is being done, because stat'ing
	+ * every file in the directory is relatively expensive.
	+ */
	+
	+ dirp = opendir(dir);
	+ if (dirp == NULL)
	+ return (NULL);
	+ last = NULL;
	+
	+ while ((dent = readdir(dirp)) != NULL) {
	+ int isdir;
	+ if (strncmp(cp, dent->d_name, len) != 0)
	+ continue;
	+ isdir = 0;
	+ if (dent->d_type == DT_DIR) {
	+ isdir = 1;
	+ } else if (dent->d_type == DT_LNK \|\|
	+ dent->d_type == DT_UNKNOWN) {
	+ struct stat statbuf;
	+
	+ if (fstatat(dirfd(dirp), dent->d_name, &statbuf, 0) < 0)
	+ continue;
	+ if (S_ISDIR(statbuf.st_mode))
	+ isdir = 1;
	+ }
	+
	+ if ((current = malloc(sizeof(struct list))) == NULL) {
	+ free_file_list(last);
	+ closedir(dirp);
	+ return (NULL);
	+ }
	+ ret = snprintf(fl_name, sizeof(fl_name),
	+ "%s%s%s", prefixx, dent->d_name, isdir ? "/" : "");
	+ if (ret < 0 \|\| ret >= sizeof(fl_name)) {
	+ free(current);
	+ continue;
	+ }
	+ current->l_next = last;
	+ current->l_name = strdup(fl_name);
	+ last = current;
	+ }
	+ closedir(dirp);
	+
	+ return (last);
	+}
	+
	+/*
	+ * Test if a supplied filename refers to a directory
	+ * Returns ABORT on error, TRUE if directory. FALSE otherwise
	+ */
	+int
	+fisdir(const char *fname)
	+{
	+ struct stat statbuf;
	+
	+ if (stat(fname, &statbuf) != 0)
	+ return (ABORT);
	+
	+ if (S_ISDIR(statbuf.st_mode))
	+ return (TRUE);
	+
	+ return (FALSE);
	+}
	+
	+/*
	+ * Check the mtime of the supplied filename.
	+ * Return TRUE if last mtime matches, FALSE if not,
	+ * If the stat fails, return TRUE and try the save anyway
	+ */
	+int
	+fchecktime(struct buffer *bp)
	+{
	+ struct stat sb;
	+
	+ if (stat(bp->b_fname, &sb) == -1)
	+ return (TRUE);
	+
	+ if (bp->b_fi.fi_mtime.tv_sec != sb.st_mtimespec.tv_sec \|\|
	+ bp->b_fi.fi_mtime.tv_nsec != sb.st_mtimespec.tv_nsec)
	+ return (FALSE);
	+
	+ return (TRUE);
	+
	+}
	+
	+/*
	+ * Location of backup file. This function creates the correct path.
	+ */
	+static char *
	+bkuplocation(const char *fn)
	+{
	+ struct stat sb;
	+ char *ret;
	+
	+ if (bkupdir != NULL && (stat(bkupdir, &sb) == 0) &&
	+ S_ISDIR(sb.st_mode) && !bkupleavetmp(fn)) {
	+ char fname[NFILEN];
	+ const char *c;
	+ int i = 0, len;
	+
	+ c = fn;
	+ len = strlen(bkupdir);
	+
	+ while (*c != '\0') {
	+ /* Make sure we don't go over combined:
	+ * strlen(bkupdir + '/' + fname + '\0')
	+ */
	+ if (i >= NFILEN - len - 1)
	+ return (NULL);
	+ if (*c == '/') {
	+ fname[i] = '!';
	+ } else if (*c == '!') {
	+ if (i >= NFILEN - len - 2)
	+ return (NULL);
	+ fname[i++] = '!';
	+ fname[i] = '!';
	+ } else
	+ fname[i] = *c;
	+ i++;
	+ c++;
	+ }
	+ fname[i] = '\0';
	+ if (asprintf(&ret, "%s/%s", bkupdir, fname) == -1)
	+ return (NULL);
	+
	+ } else if ((ret = strndup(fn, NFILEN)) == NULL)
	+ return (NULL);
	+
	+ return (ret);
	+}
	+
	+int
	+backuptohomedir(int f, int n)
	+{
	+ const char *c = _PATH_MG_DIR;
	+ char *p;
	+
	+ if (bkupdir == NULL) {
	+ p = adjustname(c, TRUE);
	+ bkupdir = strndup(p, NFILEN);
	+ if (bkupdir == NULL)
	+ return(FALSE);
	+
	+ if (mkdir(bkupdir, 0700) == -1 && errno != EEXIST) {
	+ free(bkupdir);
	+ bkupdir = NULL;
	+ }
	+ } else {
	+ free(bkupdir);
	+ bkupdir = NULL;
	+ }
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * For applications that use mg as the editor and have a desire to keep
	+ * '~' files in /tmp, toggle the location: /tmp \| ~/.mg.d
	+ */
	+int
	+toggleleavetmp(int f, int n)
	+{
	+ leavetmp = !leavetmp;
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * Returns TRUE if fn is located in the temp directory and we want to save
	+ * those backups there.
	+ */
	+int
	+bkupleavetmp(const char *fn)
	+{
	+ if (!leavetmp)
	+ return(FALSE);
	+
	+ if (strncmp(fn, "/tmp", 4) == 0)
	+ return (TRUE);
	+
	+ return (FALSE);
	+}
	+
	+/*
	+ * Expand file names beginning with '~' if appropriate:
	+ * 1, if ./~fn exists, continue without expanding tilde.
	+ * 2, else, if username 'fn' exists, expand tilde with home directory path.
	+ * 3, otherwise, continue and create new buffer called ~fn.
	+ */
	+char *
	+expandtilde(const char *fn)
	+{
	+ struct passwd *pw;
	+ struct stat statbuf;
	+ const char *cp;
	+ char user[LOGIN_NAME_MAX], path[NFILEN];
	+ char *ret;
	+ size_t ulen, plen;
	+
	+ path[0] = '\0';
	+
	+ if (fn[0] != '~' \|\| stat(fn, &statbuf) == 0) {
	+ if ((ret = strndup(fn, NFILEN)) == NULL)
	+ return (NULL);
	+ return(ret);
	+ }
	+ cp = strchr(fn, '/');
	+ if (cp == NULL)
	+ cp = fn + strlen(fn); /* point to the NUL byte */
	+ ulen = cp - &fn[1];
	+ if (ulen >= sizeof(user)) {
	+ if ((ret = strndup(fn, NFILEN)) == NULL)
	+ return (NULL);
	+ return(ret);
	+ }
	+ if (ulen == 0) /* ~/ or ~ */
	+ pw = getpwuid(geteuid());
	+ else { /* ~user/ or ~user */
	+ memcpy(user, &fn[1], ulen);
	+ user[ulen] = '\0';
	+ pw = getpwnam(user);
	+ }
	+ if (pw != NULL) {
	+ plen = strlcpy(path, pw->pw_dir, sizeof(path));
	+ if (plen == 0 \|\| path[plen - 1] != '/') {
	+ if (strlcat(path, "/", sizeof(path)) >= sizeof(path)) {
	+ dobeep();
	+ ewprintf("Path too long");
	+ return (NULL);
	+ }
	+ }
	+ fn = cp;
	+ if (*fn == '/')
	+ fn++;
	+ }
	+ if (strlcat(path, fn, sizeof(path)) >= sizeof(path)) {
	+ dobeep();
	+ ewprintf("Path too long");
	+ return (NULL);
	+ }
	+ if ((ret = strndup(path, NFILEN)) == NULL)
	+ return (NULL);
	+
	+ return (ret);
	+}
	Index: contrib/mg/fparseln.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/fparseln.c
	@@ -0,0 +1,258 @@
	+/* $NetBSD: fgetln.c,v 1.9 2008/04/29 06:53:03 martin Exp $ */
	+
	+/*-
	+ * Copyright (c) 1998 The NetBSD Foundation, Inc.
	+ * All rights reserved.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Christos Zoulas.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
	+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
	+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
	+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	+ * POSSIBILITY OF SUCH DAMAGE.
	+ */
	+
	+/* $OpenBSD: fparseln.c,v 1.7 2012/12/05 23:20:06 deraadt Exp $ */
	+/* $NetBSD: fparseln.c,v 1.7 1999/07/02 15:49:12 simonb Exp $ */
	+
	+/*
	+ * Copyright (c) 1997 Christos Zoulas. All rights reserved.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ * 3. All advertising materials mentioning features or use of this software
	+ * must display the following acknowledgement:
	+ * This product includes software developed by Christos Zoulas.
	+ * 4. The name of the author may not be used to endorse or promote products
	+ * derived from this software without specific prior written permission.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ */
	+
	+#include <errno.h>
	+#include <stdio.h>
	+#include <string.h>
	+#include <stdlib.h>
	+
	+#include "config.h"
	+
	+#ifndef HAVE_FPARSELN
	+
	+#ifndef __APPLE__
	+#include "util.h"
	+#endif
	+
	+static char *
	+efgetln(FILE fp, size_t len)
	+{
	+ static char *buf = NULL;
	+ static size_t bufsiz = 0;
	+ char *ptr;
	+
	+
	+ if (buf == NULL) {
	+ bufsiz = BUFSIZ;
	+ if ((buf = malloc(bufsiz)) == NULL)
	+ return NULL;
	+ }
	+
	+ if (fgets(buf, bufsiz, fp) == NULL)
	+ return NULL;
	+
	+ *len = 0;
	+ while ((ptr = strchr(&buf[*len], '\n')) == NULL) {
	+ size_t nbufsiz = bufsiz + BUFSIZ;
	+ char *nbuf = realloc(buf, nbufsiz);
	+
	+ if (nbuf == NULL) {
	+ int oerrno = errno;
	+ free(buf);
	+ errno = oerrno;
	+ buf = NULL;
	+ return NULL;
	+ } else
	+ buf = nbuf;
	+
	+ if (fgets(&buf[bufsiz], BUFSIZ, fp) == NULL) {
	+ buf[bufsiz] = '\0';
	+ *len = strlen(buf);
	+ return buf;
	+ }
	+
	+ *len = bufsiz;
	+ bufsiz = nbufsiz;
	+ }
	+
	+ *len = (ptr - buf) + 1;
	+ return buf;
	+}
	+
	+static int isescaped(const char , const char , int);
	+
	+/* isescaped():
	+ * Return true if the character in *p that belongs to a string
	+ * that starts in *sp, is escaped by the escape character esc.
	+ */
	+static int
	+isescaped(const char sp, const char p, int esc)
	+{
	+ const char *cp;
	+ size_t ne;
	+
	+ /* No escape character */
	+ if (esc == '\0')
	+ return 1;
	+
	+ /* Count the number of escape characters that precede ours */
	+ for (ne = 0, cp = p; --cp >= sp && *cp == esc; ne++)
	+ continue;
	+
	+ /* Return true if odd number of escape characters */
	+ return (ne & 1) != 0;
	+}
	+
	+
	+/* fparseln():
	+ * Read a line from a file parsing continuations ending in \
	+ * and eliminating trailing newlines, or comments starting with
	+ * the comment char.
	+ */
	+char *
	+fparseln(FILE fp, size_t size, size_t *lineno, const char str[3],
	+ int flags)
	+{
	+ static const char dstr[3] = { '\\', '\\', '#' };
	+ char buf = NULL, ptr, *cp, esc, con, nl, com;
	+ size_t s, len = 0;
	+ int cnt = 1;
	+
	+ if (str == NULL)
	+ str = dstr;
	+
	+ esc = str[0];
	+ con = str[1];
	+ com = str[2];
	+
	+ /*
	+ * XXX: it would be cool to be able to specify the newline character,
	+ * but unfortunately, fgetln does not let us
	+ */
	+ nl = '\n';
	+
	+ while (cnt) {
	+ cnt = 0;
	+
	+ if (lineno)
	+ (*lineno)++;
	+
	+ if ((ptr = efgetln(fp, &s)) == NULL)
	+ break;
	+
	+ if (s && com) { /* Check and eliminate comments */
	+ for (cp = ptr; cp < ptr + s; cp++)
	+ if (*cp == com && !isescaped(ptr, cp, esc)) {
	+ s = cp - ptr;
	+ cnt = s == 0 && buf == NULL;
	+ break;
	+ }
	+ }
	+
	+ if (s && nl) { /* Check and eliminate newlines */
	+ cp = &ptr[s - 1];
	+
	+ if (*cp == nl)
	+ s--; /* forget newline */
	+ }
	+
	+ if (s && con) { /* Check and eliminate continuations */
	+ cp = &ptr[s - 1];
	+
	+ if (*cp == con && !isescaped(ptr, cp, esc)) {
	+ s--; /* forget escape */
	+ cnt = 1;
	+ }
	+ }
	+
	+ if (s == 0 && buf != NULL)
	+ continue;
	+
	+ if ((cp = realloc(buf, len + s + 1)) == NULL) {
	+ free(buf);
	+ return NULL;
	+ }
	+ buf = cp;
	+
	+ (void) memcpy(buf + len, ptr, s);
	+ len += s;
	+ buf[len] = '\0';
	+ }
	+
	+ if ((flags & FPARSELN_UNESCALL) != 0 && esc && buf != NULL &&
	+ strchr(buf, esc) != NULL) {
	+ ptr = cp = buf;
	+ while (cp[0] != '\0') {
	+ int skipesc;
	+
	+ while (cp[0] != '\0' && cp[0] != esc)
	+ ptr++ = cp++;
	+ if (cp[0] == '\0' \|\| cp[1] == '\0')
	+ break;
	+
	+ skipesc = 0;
	+ if (cp[1] == com)
	+ skipesc += (flags & FPARSELN_UNESCCOMM);
	+ if (cp[1] == con)
	+ skipesc += (flags & FPARSELN_UNESCCONT);
	+ if (cp[1] == esc)
	+ skipesc += (flags & FPARSELN_UNESCESC);
	+ if (cp[1] != com && cp[1] != con && cp[1] != esc)
	+ skipesc = (flags & FPARSELN_UNESCREST);
	+
	+ if (skipesc)
	+ cp++;
	+ else
	+ ptr++ = cp++;
	+ ptr++ = cp++;
	+ }
	+ *ptr = '\0';
	+ len = strlen(buf);
	+ }
	+
	+ if (size)
	+ *size = len;
	+ return buf;
	+}
	+
	+#endif /* !HAVE_FPARSELN */
	Index: contrib/mg/freebsd.h
	===================================================================
	--- /dev/null
	+++ contrib/mg/freebsd.h
	@@ -0,0 +1,6 @@
	+/*
	+ * FreeBSD-specific support.
	+ */
	+
	+#include <sys/param.h>
	+#include <time.h>
	Index: contrib/mg/fstatat.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/fstatat.c
	@@ -0,0 +1,22 @@
	+/*
	+ * fstatat(2) wrapper for systems that do not support it.
	+ * Written by Brian Callahan <bcallah@openbsd.org> and released
	+ * into the Public Domain.
	+ */
	+
	+#include <sys/stat.h>
	+
	+#include <stdio.h>
	+
	+#include "config.h"
	+
	+#ifndef HAVE_FSTATAT
	+
	+int
	+fstatat(int fd, const char path, struct stat buf, int flag)
	+{
	+
	+ return stat(path, buf);
	+}
	+
	+#endif /* !HAVE_FSTATAT */
	Index: contrib/mg/funmap.h
	===================================================================
	--- /dev/null
	+++ contrib/mg/funmap.h
	@@ -0,0 +1,10 @@
	+/* $OpenBSD: funmap.h,v 1.8 2019/07/11 18:20:18 lum Exp $ */
	+
	+/* This file is in the public domain */
	+
	+void funmap_init(void);
	+PF name_function(const char *);
	+const char *function_name(PF);
	+struct list complete_function_list(const char );
	+int funmap_add(PF, const char *, int);
	+int numparams_function(PF);
	Index: contrib/mg/funmap.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/funmap.c
	@@ -0,0 +1,339 @@
	+/* $OpenBSD: funmap.c,v 1.63 2021/04/22 19:50:55 lum Exp $ */
	+
	+/* This file is in the public domain */
	+
	+#include <sys/queue.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+
	+#include "def.h"
	+#include "funmap.h"
	+#include "kbd.h"
	+
	+/*
	+ * funmap structure: a list of functions and their command-names/#parameters.
	+ *
	+ * If the function is NULL, it must be listed with the same name in the
	+ * map_table.
	+ */
	+struct funmap {
	+ PF fn_funct;
	+ const char *fn_name;
	+ int fn_nparams;
	+ struct funmap *fn_next;
	+};
	+static struct funmap *funs;
	+
	+/*
	+ * 3rd column in the functnames structure indicates how many parameters the
	+ * function takes in 'normal' usage. This column is only used to identify
	+ * function profiles when lines of a buffer are being evaluated via excline().
	+ *
	+ * 0 = a toggle, non-modifiable insert/delete, region modifier, etc
	+ * 1 = value can be string or number value (like: file/buf name, search string)
	+ * 2 = multiple type value required, see auto-execute, or global-set-key, etc
	+ * -1 = error: interactive commmand, unsuitable for interpreter
	+ *
	+ * Some functions when used interactively may ask for a 'y' or 'n' (or another
	+ * character) to continue, in excline, a 'y' is assumed. Functions like this
	+ * have '0' in the 3rd column below.
	+ */
	+static struct funmap functnames[] = {
	+ {apropos_command, "apropos", 1},
	+ {toggleaudiblebell, "audible-bell", 0},
	+ {auto_execute, "auto-execute", 2},
	+ {fillmode, "auto-fill-mode", 0},
	+ {indentmode, "auto-indent-mode", 0},
	+ {backtoindent, "back-to-indentation", 0},
	+ {backuptohomedir, "backup-to-home-directory", 0},
	+ {backchar, "backward-char", 1},
	+ {delbword, "backward-kill-word", 1},
	+ {gotobop, "backward-paragraph", 1},
	+ {backword, "backward-word", 1},
	+ {gotobob, "beginning-of-buffer", 0},
	+ {gotobol, "beginning-of-line", 0},
	+ {showmatch, "blink-and-insert", 1}, /* startup only */
	+ {bsmap, "bsmap-mode", 0},
	+ {NULL, "c-x 4 prefix", 0}, /* internal */
	+ {NULL, "c-x prefix", 0}, /* internal */
	+ {executemacro, "call-last-kbd-macro", 0},
	+ {capword, "capitalize-word", 1},
	+ {changedir, "cd", 1},
	+ {clearmark, "clear-mark", 0},
	+ {colnotoggle, "column-number-mode", 0},
	+ {copyregion, "copy-region-as-kill", 0},
	+#ifdef REGEX
	+ {cntmatchlines, "count-matches", 1},
	+ {cntnonmatchlines, "count-non-matches", 1},
	+#endif /* REGEX */
	+ {cscreatelist, "cscope-create-list-of-files-to-index", 1},
	+ {csfuncalled, "cscope-find-called-functions", 1},
	+ {csegrep, "cscope-find-egrep-pattern", 1},
	+ {csfindinc, "cscope-find-files-including-file", 1},
	+ {cscallerfuncs, "cscope-find-functions-calling-this-function", 1},
	+ {csdefinition, "cscope-find-global-definition", 1},
	+ {csfindfile, "cscope-find-this-file", 1},
	+ {cssymbol, "cscope-find-this-symbol", 1},
	+ {csfindtext, "cscope-find-this-text-string", 1},
	+ {csnextfile, "cscope-next-file", 0},
	+ {csnextmatch, "cscope-next-symbol", 0},
	+ {csprevfile, "cscope-prev-file", 0},
	+ {csprevmatch, "cscope-prev-symbol", 0},
	+ {redefine_key, "define-key", 3},
	+ {backdel, "delete-backward-char", 1},
	+ {deblank, "delete-blank-lines", 0},
	+ {forwdel, "delete-char", 1},
	+ {delwhite, "delete-horizontal-space", 0},
	+ {delleadwhite, "delete-leading-space", 0},
	+#ifdef REGEX
	+ {delmatchlines, "delete-matching-lines", 1},
	+ {delnonmatchlines, "delete-non-matching-lines", 1},
	+#endif /* REGEX */
	+ {onlywind, "delete-other-windows", 0},
	+ {deltrailwhite, "delete-trailing-space", 0},
	+ {delwind, "delete-window", 0},
	+ {wallchart, "describe-bindings", 0},
	+ {desckey, "describe-key-briefly", 1},
	+ {diffbuffer, "diff-buffer-with-file", 0},
	+ {digit_argument, "digit-argument", 1},
	+ {dired_jump, "dired-jump", 1},
	+ {lowerregion, "downcase-region", 0},
	+ {lowerword, "downcase-word", 1},
	+ {showversion, "emacs-version", 0},
	+ {finishmacro, "end-kbd-macro", 0},
	+ {gotoeob, "end-of-buffer", 0},
	+ {gotoeol, "end-of-line", 0},
	+ {enlargewind, "enlarge-window", 0},
	+ {NULL, "esc prefix", 0}, /* internal */
	+ {evalbuffer, "eval-current-buffer", 0},
	+ {evalexpr, "eval-expression", 0},
	+ {swapmark, "exchange-point-and-mark", 0},
	+ {extend, "execute-extended-command", 1},
	+ {fillpara, "fill-paragraph", 0},
	+ {filevisitalt, "find-alternate-file", 1},
	+ {filevisit, "find-file", 1},
	+ {poptofile, "find-file-other-window", 1},
	+ {filevisitro, "find-file-read-only", 1},
	+ {findtag, "find-tag", 1},
	+ {forwchar, "forward-char", 1},
	+ {gotoeop, "forward-paragraph", 1},
	+ {forwword, "forward-word", 1},
	+ {bindtokey, "global-set-key", 2},
	+ {unbindtokey, "global-unset-key", 1},
	+ {globalwdtoggle, "global-wd-mode", 0},
	+ {gotoline, "goto-line", 1},
	+ {help_help, "help-help", 0},
	+ {indent, "indent-current-line", 0},
	+ {insert, "insert", 1},
	+ {bufferinsert, "insert-buffer", 1},
	+ {fileinsert, "insert-file", 1},
	+ {fillword, "insert-with-wrap", 1}, /* startup only */
	+ {backisearch, "isearch-backward", 1},
	+ {forwisearch, "isearch-forward", 1},
	+ {joinline, "join-line", 0},
	+ {justone, "just-one-space", 0},
	+ {ctrlg, "keyboard-quit", 0},
	+ {killbuffer_cmd, "kill-buffer", 1},
	+ {killline, "kill-line", 1},
	+ {killpara, "kill-paragraph", 1},
	+ {killregion, "kill-region", 0},
	+ {delfword, "kill-word", 1},
	+ {toggleleavetmp, "leave-tmpdir-backups", 0},
	+ {linenotoggle, "line-number-mode", 0},
	+ {listbuffers, "list-buffers", 0},
	+ {evalfile, "load", 1},
	+ {localbind, "local-set-key", 1},
	+ {localunbind, "local-unset-key", 1},
	+ {makebkfile, "make-backup-files", 0},
	+ {makedir, "make-directory", 1},
	+ {markpara, "mark-paragraph", 1},
	+ {markbuffer, "mark-whole-buffer", 0},
	+ {do_meta, "meta-key-mode", 0}, /* better name, anyone? */
	+ {negative_argument, "negative-argument", 1},
	+ {enewline, "newline", 1},
	+ {lfindent, "newline-and-indent", 1},
	+ {forwline, "next-line", 1},
	+#ifdef NOTAB
	+ {notabmode, "no-tab-mode", 0},
	+#endif /* NOTAB */
	+ {notmodified, "not-modified", 0},
	+ {openline, "open-line", 1},
	+ {nextwind, "other-window", 0},
	+ {overwrite_mode, "overwrite-mode", 0},
	+ {poptag, "pop-tag-mark", 0},
	+ {prefixregion, "prefix-region", 0},
	+ {backline, "previous-line", 1},
	+ {prevwind, "previous-window", 0},
	+ {spawncli, "push-shell", 0},
	+ {showcwdir, "pwd", 0},
	+ {queryrepl, "query-replace", -1},
	+#ifdef REGEX
	+ {re_queryrepl, "query-replace-regexp", -1},
	+#endif /* REGEX */
	+ {quote, "quoted-insert", 1},
	+#ifdef REGEX
	+ {re_searchagain, "re-search-again", 0},
	+ {re_backsearch, "re-search-backward", 0},
	+ {re_forwsearch, "re-search-forward", 0},
	+#endif /* REGEX */
	+ {reposition, "recenter", 0},
	+ {redraw, "redraw-display", 0},
	+#ifdef REGEX
	+ {re_repl, "replace-regexp", 2},
	+ {replstr, "replace-string", 2},
	+#endif /* REGEX */
	+ {revertbuffer, "revert-buffer", 0},
	+ {filesave, "save-buffer", 1},
	+ {quit, "save-buffers-kill-emacs", 0},
	+ {savebuffers, "save-some-buffers", 0},
	+ {backpage, "scroll-down", 1},
	+ {back1page, "scroll-one-line-down", 1},
	+ {forw1page, "scroll-one-line-up", 1},
	+ {pagenext, "scroll-other-window", 1},
	+ {forwpage, "scroll-up", 1},
	+ {searchagain, "search-again", 0},
	+ {backsearch, "search-backward", 0},
	+ {forwsearch, "search-forward", 0},
	+ {ask_selfinsert, "self-insert-char", 1},
	+ {selfinsert, "self-insert-command", 1}, /* startup only */
	+ {sentencespace, "sentence-end-double-space", 0},
	+#ifdef REGEX
	+ {setcasefold, "set-case-fold-search", 0},
	+#endif /* REGEX */
	+ {setcasereplace, "set-case-replace", 0},
	+ {set_default_mode, "set-default-mode", 1},
	+ {setfillcol, "set-fill-column", 1},
	+ {setmark, "set-mark-command", 0},
	+ {setprefix, "set-prefix-string", 1},
	+ {shellcommand, "shell-command", 1},
	+ {piperegion, "shell-command-on-region", 1},
	+ {shrinkwind, "shrink-window", 1},
	+#ifdef NOTAB
	+ {space_to_tabstop, "space-to-tabstop", 0},
	+#endif /* NOTAB */
	+ {splitwind, "split-window-vertically", 0},
	+ {definemacro, "start-kbd-macro", 0},
	+ {spawncli, "suspend-emacs", 0},
	+ {usebuffer, "switch-to-buffer", 1},
	+ {poptobuffer, "switch-to-buffer-other-window", 1},
	+#ifndef NOEXTENSIONS
	+ {togglenewlineprompt, "toggle-newline-prompt",},
	+#endif /* NOEXTENSIONS */
	+ {togglereadonly, "toggle-read-only", 0},
	+ {togglereadonlyall, "toggle-read-only-all", 0},
	+ {twiddle, "transpose-chars", 0},
	+ {transposepara, "transpose-paragraphs", 0},
	+ {transposeword, "transpose-words", 0},
	+ {undo, "undo", 0},
	+ {undo_add_boundary, "undo-boundary", 0},
	+ {undo_boundary_enable, "undo-boundary-toggle", 0},
	+ {undo_enable, "undo-enable", 0},
	+ {undo_dump, "undo-list", 0},
	+ {universal_argument, "universal-argument", 1},
	+ {upperregion, "upcase-region", 0},
	+ {upperword, "upcase-word", 1},
	+ {togglevisiblebell, "visible-bell", 0},
	+ {tagsvisit, "visit-tags-table", 0},
	+ {showcpos, "what-cursor-position", 0},
	+ {filewrite, "write-file", 1},
	+ {yank, "yank", 1},
	+ {NULL, NULL, 0}
	+};
	+
	+void
	+funmap_init(void)
	+{
	+ struct funmap *fn;
	+
	+ for (fn = functnames; fn->fn_name != NULL; fn++) {
	+ fn->fn_next = funs;
	+ funs = fn;
	+ }
	+}
	+
	+int
	+funmap_add(PF fun, const char *fname, int fparams)
	+{
	+ struct funmap *fn;
	+
	+ if ((fn = malloc(sizeof(*fn))) == NULL)
	+ return (FALSE);
	+
	+ fn->fn_funct = fun;
	+ fn->fn_name = fname;
	+ fn->fn_nparams = fparams;
	+ fn->fn_next = funs;
	+
	+ funs = fn;
	+ return (TRUE);
	+}
	+
	+/*
	+ * Translate from function name to function pointer.
	+ */
	+PF
	+name_function(const char *fname)
	+{
	+ struct funmap *fn;
	+
	+ for (fn = funs; fn != NULL; fn = fn->fn_next) {
	+ if (strcmp(fn->fn_name, fname) == 0)
	+ return (fn->fn_funct);
	+ }
	+ return (NULL);
	+}
	+
	+const char *
	+function_name(PF fun)
	+{
	+ struct funmap *fn;
	+
	+ for (fn = funs; fn != NULL; fn = fn->fn_next) {
	+ if (fn->fn_funct == fun)
	+ return (fn->fn_name);
	+ }
	+ return (NULL);
	+}
	+
	+/*
	+ * List possible function name completions.
	+ */
	+struct list *
	+complete_function_list(const char *fname)
	+{
	+ struct funmap *fn;
	+ struct list head, el;
	+ int len;
	+
	+ len = strlen(fname);
	+ head = NULL;
	+ for (fn = funs; fn != NULL; fn = fn->fn_next) {
	+ if (memcmp(fname, fn->fn_name, len) == 0) {
	+ if ((el = malloc(sizeof(*el))) == NULL) {
	+ free_file_list(head);
	+ return (NULL);
	+ }
	+ el->l_name = strdup(fn->fn_name);
	+ el->l_next = head;
	+ head = el;
	+ }
	+ }
	+ return (head);
	+}
	+
	+/*
	+ * Find number of parameters for function name.
	+ */
	+int
	+numparams_function(PF fun)
	+{
	+ struct funmap *fn;
	+
	+ for (fn = funs; fn != NULL; fn = fn->fn_next) {
	+ if (fn->fn_funct == fun)
	+ return (fn->fn_nparams);
	+ }
	+ return (FALSE);
	+}
	Index: contrib/mg/futimens.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/futimens.c
	@@ -0,0 +1,20 @@
	+/* This file is in the public domain. */
	+
	+#include <sys/time.h>
	+
	+#include <stdio.h>
	+
	+#include "config.h"
	+
	+#ifndef HAVE_FUTIMENS
	+
	+int
	+futimens(int fildes, const struct timespec times[2])
	+{
	+ struct timeval timevals[2];
	+ TIMESPEC_TO_TIMEVAL(&timevals[0], &times[0]);
	+ TIMESPEC_TO_TIMEVAL(&timevals[1], &times[1]);
	+ return futimes(fildes, timevals);
	+}
	+
	+#endif /* !HAVE_FUTIMENS */
	Index: contrib/mg/getline.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/getline.c
	@@ -0,0 +1,89 @@
	+/* $NetBSD: getdelim.c,v 1.2 2015/12/25 20:12:46 joerg Exp $ */
	+/* NetBSD-src: getline.c,v 1.2 2014/09/16 17:23:50 christos Exp */
	+
	+/*-
	+ * Copyright (c) 2011 The NetBSD Foundation, Inc.
	+ * All rights reserved.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Christos Zoulas.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
	+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
	+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
	+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	+ * POSSIBILITY OF SUCH DAMAGE.
	+ */
	+
	+#include <stdio.h>
	+#include <stdlib.h>
	+
	+#include "config.h"
	+
	+#ifndef HAVE_GETLINE
	+
	+static ssize_t
	+getdelim(char *buf, size_t bufsiz, int delimiter, FILE *fp)
	+{
	+ char ptr, eptr;
	+
	+
	+ if (buf == NULL \|\| bufsiz == 0) {
	+ *bufsiz = BUFSIZ;
	+ if ((buf = malloc(bufsiz)) == NULL)
	+ return -1;
	+ }
	+
	+ for (ptr = buf, eptr = buf + *bufsiz;;) {
	+ int c = fgetc(fp);
	+ if (c == -1) {
	+ if (feof(fp)) {
	+ ssize_t diff = (ssize_t)(ptr - *buf);
	+ if (diff != 0) {
	+ *ptr = '\0';
	+ return diff;
	+ }
	+ }
	+ return -1;
	+ }
	+ *ptr++ = c;
	+ if (c == delimiter) {
	+ *ptr = '\0';
	+ return ptr - *buf;
	+ }
	+ if (ptr + 2 >= eptr) {
	+ char *nbuf;
	+ size_t nbufsiz = bufsiz 2;
	+ ssize_t d = ptr - *buf;
	+ if ((nbuf = realloc(*buf, nbufsiz)) == NULL)
	+ return -1;
	+ *buf = nbuf;
	+ *bufsiz = nbufsiz;
	+ eptr = nbuf + nbufsiz;
	+ ptr = nbuf + d;
	+ }
	+ }
	+}
	+
	+ssize_t
	+getline(char *buf, size_t bufsiz, FILE *fp)
	+{
	+ return getdelim(buf, bufsiz, '\n', fp);
	+}
	+
	+#endif
	Index: contrib/mg/graph2.h
	===================================================================
	--- /dev/null
	+++ contrib/mg/graph2.h
	@@ -0,0 +1,63 @@
	+/* $NetBSD: graph2.h,v 1.1 2009/08/15 16:21:05 joerg Exp $ */
	+/*-
	+ * Copyright (c) 2009 The NetBSD Foundation, Inc.
	+ * All rights reserved.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Joerg Sonnenberger.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ *
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in
	+ * the documentation and/or other materials provided with the
	+ * distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
	+ * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
	+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
	+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	+ * SUCH DAMAGE.
	+ */
	+
	+/*
	+ * Implementation of common 2-graph routines:
	+ * - build a 2-graph with hash-pairs as edges
	+ * - check a 2-graph for acyclicness and compute an output order
	+ */
	+
	+struct vertex2 {
	+ uint32_t l_edge, r_edge;
	+};
	+
	+struct edge2 {
	+ uint32_t left, right;
	+ uint32_t l_prev, l_next;
	+ uint32_t r_prev, r_next;
	+};
	+
	+struct graph2 {
	+ struct vertex2 *verts;
	+ struct edge2 *edges;
	+ uint32_t output_index;
	+ uint32_t *output_order;
	+ uint8_t *visited;
	+ uint32_t e, v;
	+};
	+
	+void graph2_setup(struct graph2 *, uint32_t, uint32_t);
	+void graph2_free(struct graph2 *);
	+
	+int graph2_hash(struct nbperf , struct graph2 );
	+int graph2_output_order(struct graph2 *graph);
	Index: contrib/mg/graph2.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/graph2.c
	@@ -0,0 +1,206 @@
	+/* $NetBSD: graph2.c,v 1.4 2011/10/21 23:47:11 joerg Exp $ */
	+/*-
	+ * Copyright (c) 2009 The NetBSD Foundation, Inc.
	+ * All rights reserved.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Joerg Sonnenberger.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ *
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in
	+ * the documentation and/or other materials provided with the
	+ * distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
	+ * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
	+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
	+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	+ * SUCH DAMAGE.
	+ */
	+
	+#include <sys/cdefs.h>
	+
	+#include <err.h>
	+#include <inttypes.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+
	+#include "nbperf.h"
	+#include "graph2.h"
	+
	+static const uint32_t unused = 0xffffffffU;
	+
	+void
	+graph2_setup(struct graph2 *graph, uint32_t v, uint32_t e)
	+{
	+ graph->v = v;
	+ graph->e = e;
	+
	+ graph->verts = calloc(sizeof(struct vertex2), v);
	+ graph->edges = calloc(sizeof(struct edge2), e);
	+ graph->output_order = calloc(sizeof(uint32_t), e);
	+
	+ if (graph->verts == NULL \|\| graph->edges == NULL \|\|
	+ graph->output_order == NULL)
	+ err(1, "malloc failed");
	+}
	+
	+void
	+graph2_free(struct graph2 *graph)
	+{
	+ free(graph->verts);
	+ free(graph->edges);
	+ free(graph->output_order);
	+
	+ graph->verts = NULL;
	+ graph->edges = NULL;
	+ graph->output_order = NULL;
	+}
	+
	+static int
	+graph2_check_duplicates(struct nbperf nbperf, struct graph2 graph)
	+{
	+ struct vertex2 *v;
	+ struct edge2 e, e2;
	+ uint32_t i, j;
	+
	+ for (i = 0; i < graph->e; ++i) {
	+ e = &graph->edges[i];
	+ v = &graph->verts[e->left];
	+ j = v->l_edge;
	+ e2 = &graph->edges[j];
	+ for (;;) {
	+ if (i < j && e->right == e2->right &&
	+ nbperf->keylens[i] == nbperf->keylens[j] &&
	+ memcmp(nbperf->keys[i], nbperf->keys[j],
	+ nbperf->keylens[i]) == 0) {
	+ nbperf->has_duplicates = 1;
	+ return -1;
	+ }
	+ if (e2->l_next == unused)
	+ break;
	+ j = e2->l_next;
	+ e2 = &graph->edges[j];
	+ }
	+ }
	+ return 0;
	+}
	+
	+int
	+graph2_hash(struct nbperf nbperf, struct graph2 graph)
	+{
	+ struct vertex2 *v;
	+ uint32_t hashes[NBPERF_MAX_HASH_SIZE];
	+ size_t i;
	+
	+ for (i = 0; i < graph->e; ++i) {
	+ (*nbperf->compute_hash)(nbperf,
	+ nbperf->keys[i], nbperf->keylens[i], hashes);
	+ graph->edges[i].left = hashes[0] % graph->v;
	+ graph->edges[i].right = hashes[1] % graph->v;
	+ if (graph->edges[i].left == graph->edges[i].right)
	+ return -1;
	+ }
	+
	+ for (i = 0; i < graph->v; ++i) {
	+ graph->verts[i].l_edge = unused;
	+ graph->verts[i].r_edge = unused;
	+ }
	+
	+ for (i = 0; i < graph->e; ++i) {
	+ v = &graph->verts[graph->edges[i].left];
	+ if (v->l_edge != unused)
	+ graph->edges[v->l_edge].l_prev = i;
	+ graph->edges[i].l_next = v->l_edge;
	+ graph->edges[i].l_prev = unused;
	+ v->l_edge = i;
	+
	+ v = &graph->verts[graph->edges[i].right];
	+ if (v->r_edge != unused)
	+ graph->edges[v->r_edge].r_prev = i;
	+ graph->edges[i].r_next = v->r_edge;
	+ graph->edges[i].r_prev = unused;
	+ v->r_edge = i;
	+ }
	+
	+ if (nbperf->first_round) {
	+ nbperf->first_round = 0;
	+ return graph2_check_duplicates(nbperf, graph);
	+ }
	+
	+ return 0;
	+}
	+
	+static void
	+graph2_remove_vertex(struct graph2 graph, struct vertex2 v)
	+{
	+ struct edge2 *e;
	+ struct vertex2 *v2;
	+
	+ for (;;) {
	+ if (v->l_edge != unused && v->r_edge != unused)
	+ break;
	+ if (v->l_edge == unused && v->r_edge == unused)
	+ break;
	+
	+ if (v->l_edge != unused) {
	+ e = &graph->edges[v->l_edge];
	+ if (e->l_next != unused)
	+ break;
	+ v->l_edge = unused; /* No other elements possible! */
	+ v2 = &graph->verts[e->right];
	+ if (e->r_prev == unused)
	+ v2->r_edge = e->r_next;
	+ else
	+ graph->edges[e->r_prev].r_next = e->r_next;
	+ if (e->r_next != unused)
	+ graph->edges[e->r_next].r_prev = e->r_prev;
	+ v = v2;
	+ } else {
	+ e = &graph->edges[v->r_edge];
	+ if (e->r_next != unused)
	+ break;
	+ v->r_edge = unused; /* No other elements possible! */
	+ v2 = &graph->verts[e->left];
	+ if (e->l_prev == unused)
	+ v2->l_edge = e->l_next;
	+ else
	+ graph->edges[e->l_prev].l_next = e->l_next;
	+ if (e->l_next != unused)
	+ graph->edges[e->l_next].l_prev = e->l_prev;
	+ v = v2;
	+ }
	+
	+ graph->output_order[--graph->output_index] = e - graph->edges;
	+ }
	+}
	+
	+int
	+graph2_output_order(struct graph2 *graph)
	+{
	+ size_t i;
	+
	+ graph->output_index = graph->e;
	+
	+ for (i = 0; i < graph->v; ++i)
	+ graph2_remove_vertex(graph, &graph->verts[i]);
	+
	+ if (graph->output_index != 0)
	+ return -1;
	+
	+ return 0;
	+}
	Index: contrib/mg/graph3.h
	===================================================================
	--- /dev/null
	+++ contrib/mg/graph3.h
	@@ -0,0 +1,62 @@
	+/* $NetBSD: graph3.h,v 1.1 2009/08/15 16:21:05 joerg Exp $ */
	+/*-
	+ * Copyright (c) 2009 The NetBSD Foundation, Inc.
	+ * All rights reserved.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Joerg Sonnenberger.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ *
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in
	+ * the documentation and/or other materials provided with the
	+ * distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
	+ * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
	+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
	+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	+ * SUCH DAMAGE.
	+ */
	+
	+/*
	+ * Implementation of common 3-graph routines:
	+ * - build a 3-graph with hash-triple as edges
	+ * - check a 3-graph for acyclicness and compute an output order
	+ */
	+
	+struct vertex3 {
	+ uint32_t l_edge, m_edge, r_edge;
	+};
	+
	+struct edge3 {
	+ uint32_t left, middle, right;
	+ uint32_t l_prev, m_prev, l_next;
	+ uint32_t r_prev, m_next, r_next;
	+};
	+
	+struct graph3 {
	+ struct vertex3 *verts;
	+ struct edge3 *edges;
	+ uint32_t output_index;
	+ uint32_t *output_order;
	+ uint32_t e, v;
	+};
	+
	+void graph3_setup(struct graph3 *, uint32_t, uint32_t);
	+void graph3_free(struct graph3 *);
	+
	+int graph3_hash(struct nbperf , struct graph3 );
	+int graph3_output_order(struct graph3 *);
	Index: contrib/mg/graph3.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/graph3.c
	@@ -0,0 +1,245 @@
	+/* $NetBSD: graph3.c,v 1.4 2011/10/21 23:47:11 joerg Exp $ */
	+/*-
	+ * Copyright (c) 2009 The NetBSD Foundation, Inc.
	+ * All rights reserved.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Joerg Sonnenberger.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ *
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in
	+ * the documentation and/or other materials provided with the
	+ * distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
	+ * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
	+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
	+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	+ * SUCH DAMAGE.
	+ */
	+
	+#include <sys/cdefs.h>
	+
	+#include <err.h>
	+#include <inttypes.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+
	+#include "nbperf.h"
	+#include "graph3.h"
	+
	+static const uint32_t unused = 0xffffffffU;
	+
	+void
	+graph3_setup(struct graph3 *graph, uint32_t v, uint32_t e)
	+{
	+ graph->v = v;
	+ graph->e = e;
	+
	+ graph->verts = calloc(sizeof(struct vertex3), v);
	+ graph->edges = calloc(sizeof(struct edge3), e);
	+ graph->output_order = calloc(sizeof(uint32_t), e);
	+
	+ if (graph->verts == NULL \|\| graph->edges == NULL \|\|
	+ graph->output_order == NULL)
	+ err(1, "malloc failed");
	+}
	+
	+void
	+graph3_free(struct graph3 *graph)
	+{
	+ free(graph->verts);
	+ free(graph->edges);
	+ free(graph->output_order);
	+
	+ graph->verts = NULL;
	+ graph->edges = NULL;
	+ graph->output_order = NULL;
	+}
	+
	+static int
	+graph3_check_duplicates(struct nbperf nbperf, struct graph3 graph)
	+{
	+ struct vertex3 *v;
	+ struct edge3 e, e2;
	+ uint32_t i, j;
	+
	+ for (i = 0; i < graph->e; ++i) {
	+ e = &graph->edges[i];
	+ v = &graph->verts[e->left];
	+ j = v->l_edge;
	+ e2 = &graph->edges[j];
	+ for (;;) {
	+ if (i < j && e->middle == e2->middle &&
	+ e->right == e2->right &&
	+ nbperf->keylens[i] == nbperf->keylens[j] &&
	+ memcmp(nbperf->keys[i], nbperf->keys[j],
	+ nbperf->keylens[i]) == 0) {
	+ nbperf->has_duplicates = 1;
	+ return -1;
	+ }
	+ if (e2->l_next == unused)
	+ break;
	+ j = e2->l_next;
	+ e2 = &graph->edges[j];
	+ }
	+ }
	+ return 0;
	+}
	+
	+int
	+graph3_hash(struct nbperf nbperf, struct graph3 graph)
	+{
	+ struct vertex3 *v;
	+ uint32_t hashes[NBPERF_MAX_HASH_SIZE];
	+ size_t i;
	+
	+ for (i = 0; i < graph->e; ++i) {
	+ (*nbperf->compute_hash)(nbperf,
	+ nbperf->keys[i], nbperf->keylens[i], hashes);
	+ graph->edges[i].left = hashes[0] % graph->v;
	+ graph->edges[i].middle = hashes[1] % graph->v;
	+ graph->edges[i].right = hashes[2] % graph->v;
	+ if (graph->edges[i].left == graph->edges[i].middle)
	+ return -1;
	+ if (graph->edges[i].left == graph->edges[i].right)
	+ return -1;
	+ if (graph->edges[i].middle == graph->edges[i].right)
	+ return -1;
	+ }
	+
	+ for (i = 0; i < graph->v; ++i) {
	+ graph->verts[i].l_edge = unused;
	+ graph->verts[i].m_edge = unused;
	+ graph->verts[i].r_edge = unused;
	+ }
	+
	+ for (i = 0; i < graph->e; ++i) {
	+ v = &graph->verts[graph->edges[i].left];
	+ if (v->l_edge != unused)
	+ graph->edges[v->l_edge].l_prev = i;
	+ graph->edges[i].l_next = v->l_edge;
	+ graph->edges[i].l_prev = unused;
	+ v->l_edge = i;
	+
	+ v = &graph->verts[graph->edges[i].middle];
	+ if (v->m_edge != unused)
	+ graph->edges[v->m_edge].m_prev = i;
	+ graph->edges[i].m_next = v->m_edge;
	+ graph->edges[i].m_prev = unused;
	+ v->m_edge = i;
	+
	+ v = &graph->verts[graph->edges[i].right];
	+ if (v->r_edge != unused)
	+ graph->edges[v->r_edge].r_prev = i;
	+ graph->edges[i].r_next = v->r_edge;
	+ graph->edges[i].r_prev = unused;
	+ v->r_edge = i;
	+ }
	+
	+ if (nbperf->first_round) {
	+ nbperf->first_round = 0;
	+ return graph3_check_duplicates(nbperf, graph);
	+ }
	+
	+ return 0;
	+}
	+
	+static void
	+graph3_remove_vertex(struct graph3 graph, struct vertex3 v)
	+{
	+ struct edge3 *e;
	+ struct vertex3 vl, vm, *vr;
	+
	+ if (v->l_edge != unused && v->m_edge != unused)
	+ return;
	+ if (v->l_edge != unused && v->r_edge != unused)
	+ return;
	+ if (v->m_edge != unused && v->r_edge != unused)
	+ return;
	+ if (v->l_edge == unused && v->m_edge == unused && v->r_edge == unused)
	+ return;
	+
	+ if (v->l_edge != unused) {
	+ e = &graph->edges[v->l_edge];
	+ if (e->l_next != unused)
	+ return;
	+ } else if (v->m_edge != unused) {
	+ e = &graph->edges[v->m_edge];
	+ if (e->m_next != unused)
	+ return;
	+ } else {
	+ if (v->r_edge == unused)
	+ abort();
	+ e = &graph->edges[v->r_edge];
	+ if (e->r_next != unused)
	+ return;
	+ }
	+
	+ graph->output_order[--graph->output_index] = e - graph->edges;
	+
	+ vl = &graph->verts[e->left];
	+ vm = &graph->verts[e->middle];
	+ vr = &graph->verts[e->right];
	+
	+ if (e->l_prev == unused)
	+ vl->l_edge = e->l_next;
	+ else
	+ graph->edges[e->l_prev].l_next = e->l_next;
	+ if (e->l_next != unused)
	+ graph->edges[e->l_next].l_prev = e->l_prev;
	+
	+ if (e->m_prev == unused)
	+ vm->m_edge = e->m_next;
	+ else
	+ graph->edges[e->m_prev].m_next = e->m_next;
	+ if (e->m_next != unused)
	+ graph->edges[e->m_next].m_prev = e->m_prev;
	+
	+ if (e->r_prev == unused)
	+ vr->r_edge = e->r_next;
	+ else
	+ graph->edges[e->r_prev].r_next = e->r_next;
	+ if (e->r_next != unused)
	+ graph->edges[e->r_next].r_prev = e->r_prev;
	+}
	+
	+int
	+graph3_output_order(struct graph3 *graph)
	+{
	+ struct edge3 *e;
	+ size_t i;
	+
	+ graph->output_index = graph->e;
	+
	+ for (i = 0; i < graph->v; ++i)
	+ graph3_remove_vertex(graph, &graph->verts[i]);
	+
	+ for (i = graph->e; i > 0 && i > graph->output_index;) {
	+ --i;
	+ e = &graph->edges[graph->output_order[i]];
	+
	+ graph3_remove_vertex(graph, &graph->verts[e->left]);
	+ graph3_remove_vertex(graph, &graph->verts[e->middle]);
	+ graph3_remove_vertex(graph, &graph->verts[e->right]);
	+ }
	+
	+ if (graph->output_index != 0)
	+ return -1;
	+
	+ return 0;
	+}
	Index: contrib/mg/grep.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/grep.c
	@@ -0,0 +1,362 @@
	+/* $OpenBSD: grep.c,v 1.49 2021/03/01 10:51:14 lum Exp $ */
	+
	+/* This file is in the public domain */
	+
	+#include <sys/queue.h>
	+#include <sys/types.h>
	+#include <sys/wait.h>
	+
	+#include <ctype.h>
	+#include <limits.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+#include <time.h>
	+#include <unistd.h>
	+
	+#include "def.h"
	+#include "kbd.h"
	+#include "funmap.h"
	+
	+int globalwd = FALSE;
	+static int compile_goto_error(int, int);
	+int next_error(int, int);
	+static int grep(int, int);
	+static int gid(int, int);
	+static struct buffer compile_mode(const char , const char *);
	+void grep_init(void);
	+
	+static char compile_last_command[NFILEN] = "make ";
	+
	+/*
	+ * Hints for next-error
	+ *
	+ * XXX - need some kind of callback to find out when those get killed.
	+ */
	+struct mgwin *compile_win;
	+struct buffer *compile_buffer;
	+
	+static PF compile_pf[] = {
	+ compile_goto_error
	+};
	+
	+static struct KEYMAPE (1) compilemap = {
	+ 1,
	+ 1,
	+ rescan,
	+ {
	+ { CCHR('M'), CCHR('M'), compile_pf, NULL }
	+ }
	+};
	+
	+void
	+grep_init(void)
	+{
	+ funmap_add(compile_goto_error, "compile-goto-error", 0);
	+ funmap_add(next_error, "next-error", 0);
	+ funmap_add(grep, "grep", 1);
	+ funmap_add(compile, "compile", 0);
	+ funmap_add(gid, "gid", 1);
	+ maps_add((KEYMAP *)&compilemap, "compile");
	+}
	+
	+/* ARGSUSED */
	+static int
	+grep(int f, int n)
	+{
	+ char cprompt[NFILEN], *bufp;
	+ struct buffer *bp;
	+ struct mgwin *wp;
	+
	+ (void)strlcpy(cprompt, "grep -n ", sizeof(cprompt));
	+ if ((bufp = eread("Run grep: ", cprompt, NFILEN,
	+ EFDEF \| EFNEW \| EFCR)) == NULL)
	+ return (ABORT);
	+ else if (bufp[0] == '\0')
	+ return (FALSE);
	+ if (strlcat(cprompt, " /dev/null", sizeof(cprompt)) >= sizeof(cprompt))
	+ return (FALSE);
	+
	+ if ((bp = compile_mode("grep", cprompt)) == NULL)
	+ return (FALSE);
	+ if ((wp = popbuf(bp, WNONE)) == NULL)
	+ return (FALSE);
	+ curbp = bp;
	+ compile_win = curwp = wp;
	+ return (TRUE);
	+}
	+
	+/* ARGSUSED */
	+int
	+compile(int f, int n)
	+{
	+ char cprompt[NFILEN], *bufp;
	+ struct buffer *bp;
	+ struct mgwin *wp;
	+
	+ (void)strlcpy(cprompt, compile_last_command, sizeof(cprompt));
	+ if ((bufp = eread("Compile command: ", cprompt, NFILEN,
	+ EFDEF \| EFNEW \| EFCR)) == NULL)
	+ return (ABORT);
	+ else if (bufp[0] == '\0')
	+ return (FALSE);
	+ if (savebuffers(f, n) == ABORT)
	+ return (ABORT);
	+ (void)strlcpy(compile_last_command, bufp, sizeof(compile_last_command));
	+
	+ if ((bp = compile_mode("compile", cprompt)) == NULL)
	+ return (FALSE);
	+ if ((wp = popbuf(bp, WNONE)) == NULL)
	+ return (FALSE);
	+ curbp = bp;
	+ compile_win = curwp = wp;
	+ gotoline(FFARG, 0);
	+ return (TRUE);
	+}
	+
	+/* id-utils foo. */
	+/* ARGSUSED */
	+static int
	+gid(int f, int n)
	+{
	+ char command[NFILEN];
	+ char cprompt[NFILEN], *bufp;
	+ int c;
	+ struct buffer *bp;
	+ struct mgwin *wp;
	+ int i, j, len;
	+
	+ /* catch ([^\s(){}]+)[\s(){}]* */
	+
	+ i = curwp->w_doto;
	+ /* Skip backwards over delimiters we are currently on */
	+ while (i > 0) {
	+ c = lgetc(curwp->w_dotp, i);
	+ if (isalnum(c) \|\| c == '_')
	+ break;
	+
	+ i--;
	+ }
	+
	+ /* Skip the symbol itself */
	+ for (; i > 0; i--) {
	+ c = lgetc(curwp->w_dotp, i - 1);
	+ if (!isalnum(c) && c != '_')
	+ break;
	+ }
	+ /* Fill the symbol in cprompt[] */
	+ for (j = 0; j < sizeof(cprompt) - 1 && i < llength(curwp->w_dotp);
	+ j++, i++) {
	+ c = lgetc(curwp->w_dotp, i);
	+ if (!isalnum(c) && c != '_')
	+ break;
	+ cprompt[j] = c;
	+ }
	+ cprompt[j] = '\0';
	+
	+ if ((bufp = eread("Run gid (with args): ", cprompt, NFILEN,
	+ (j ? EFDEF : 0) \| EFNEW \| EFCR)) == NULL)
	+ return (ABORT);
	+ else if (bufp[0] == '\0')
	+ return (FALSE);
	+ len = snprintf(command, sizeof(command), "gid %s", cprompt);
	+ if (len < 0 \|\| len >= sizeof(command))
	+ return (FALSE);
	+
	+ if ((bp = compile_mode("gid", command)) == NULL)
	+ return (FALSE);
	+ if ((wp = popbuf(bp, WNONE)) == NULL)
	+ return (FALSE);
	+ curbp = bp;
	+ compile_win = curwp = wp;
	+ return (TRUE);
	+}
	+
	+struct buffer *
	+compile_mode(const char name, const char command)
	+{
	+ struct buffer *bp;
	+ FILE *fpipe;
	+ char *buf;
	+ size_t sz;
	+ ssize_t len;
	+ int ret, n, status;
	+ char cwd[NFILEN], qcmd[NFILEN];
	+ char timestr[NTIME];
	+ time_t t;
	+
	+ buf = NULL;
	+ sz = 0;
	+
	+ n = snprintf(qcmd, sizeof(qcmd), "%s 2>&1", command);
	+ if (n < 0 \|\| n >= sizeof(qcmd))
	+ return (NULL);
	+
	+ bp = bfind(name, TRUE);
	+ if (bclear(bp) != TRUE)
	+ return (NULL);
	+
	+ if (getbufcwd(bp->b_cwd, sizeof(bp->b_cwd)) != TRUE)
	+ return (NULL);
	+ addlinef(bp, "cd %s", bp->b_cwd);
	+ addline(bp, qcmd);
	+ addline(bp, "");
	+
	+ if (getcwd(cwd, sizeof(cwd)) == NULL)
	+ panic("Can't get current directory!");
	+ if (chdir(bp->b_cwd) == -1) {
	+ dobeep();
	+ ewprintf("Can't change dir to %s", bp->b_cwd);
	+ return (NULL);
	+ }
	+ if ((fpipe = popen(qcmd, "r")) == NULL) {
	+ dobeep();
	+ ewprintf("Problem opening pipe");
	+ return (NULL);
	+ }
	+ while ((len = getline(&buf, &sz, fpipe)) != -1) {
	+ if (buf[len - 1] == *bp->b_nlchr)
	+ buf[len - 1] = '\0';
	+ addline(bp, buf);
	+ }
	+ free(buf);
	+ if (ferror(fpipe))
	+ ewprintf("Problem reading pipe");
	+ ret = pclose(fpipe);
	+ t = time(NULL);
	+ strftime(timestr, sizeof(timestr), "%a %b %e %T %Y", localtime(&t));
	+ addline(bp, "");
	+ if (WIFEXITED(ret)) {
	+ status = WEXITSTATUS(ret);
	+ if (status == 0)
	+ addlinef(bp, "Command finished at %s", timestr);
	+ else
	+ addlinef(bp, "Command exited abnormally with code %d "
	+ "at %s", status, timestr);
	+ } else
	+ addlinef(bp, "Subshell killed by signal %d at %s",
	+ WTERMSIG(ret), timestr);
	+
	+ bp->b_dotp = bfirstlp(bp);
	+ bp->b_modes[0] = name_mode("fundamental");
	+ bp->b_modes[1] = name_mode("compile");
	+ bp->b_nmodes = 1;
	+
	+ compile_buffer = bp;
	+
	+ if (chdir(cwd) == -1) {
	+ dobeep();
	+ ewprintf("Can't change dir back to %s", cwd);
	+ return (NULL);
	+ }
	+ return (bp);
	+}
	+
	+/* ARGSUSED */
	+static int
	+compile_goto_error(int f, int n)
	+{
	+ struct buffer *bp;
	+ struct mgwin *wp;
	+ char fname, line, lp, ln;
	+ int lineno;
	+ char *adjf, path[NFILEN];
	+ const char *errstr;
	+ struct line *last;
	+
	+ compile_win = curwp;
	+ compile_buffer = curbp;
	+ last = blastlp(compile_buffer);
	+
	+ retry:
	+ /* last line is compilation result */
	+ if (curwp->w_dotp == last)
	+ return (FALSE);
	+
	+ if ((line = linetostr(curwp->w_dotp)) == NULL)
	+ return (FALSE);
	+ lp = line;
	+ if ((fname = strsep(&lp, ":")) == NULL \|\| *fname == '\0')
	+ goto fail;
	+ if ((ln = strsep(&lp, ":")) == NULL \|\| *ln == '\0')
	+ goto fail;
	+ lineno = (int)strtonum(ln, INT_MIN, INT_MAX, &errstr);
	+ if (errstr)
	+ goto fail;
	+
	+ if (fname && fname[0] != '/') {
	+ if (getbufcwd(path, sizeof(path)) == FALSE)
	+ goto fail;
	+ if (strlcat(path, fname, sizeof(path)) >= sizeof(path))
	+ goto fail;
	+ adjf = path;
	+ } else {
	+ adjf = adjustname(fname, TRUE);
	+ }
	+ free(line);
	+
	+ if (adjf == NULL)
	+ return (FALSE);
	+
	+ if ((bp = findbuffer(adjf)) == NULL)
	+ return (FALSE);
	+ if ((wp = popbuf(bp, WNONE)) == NULL)
	+ return (FALSE);
	+ curbp = bp;
	+ curwp = wp;
	+ if (bp->b_fname[0] == '\0')
	+ readin(adjf);
	+ gotoline(FFARG, lineno);
	+ return (TRUE);
	+fail:
	+ free(line);
	+ if (curwp->w_dotp != blastlp(curbp)) {
	+ curwp->w_dotp = lforw(curwp->w_dotp);
	+ curwp->w_rflag \|= WFMOVE;
	+ goto retry;
	+ }
	+ dobeep();
	+ ewprintf("No more hits");
	+ return (FALSE);
	+}
	+
	+/* ARGSUSED */
	+int
	+next_error(int f, int n)
	+{
	+ if (compile_win == NULL \|\| compile_buffer == NULL) {
	+ dobeep();
	+ ewprintf("No compilation active");
	+ return (FALSE);
	+ }
	+ curwp = compile_win;
	+ curbp = compile_buffer;
	+ if (curwp->w_dotp == blastlp(curbp)) {
	+ dobeep();
	+ ewprintf("No more hits");
	+ return (FALSE);
	+ }
	+ curwp->w_dotp = lforw(curwp->w_dotp);
	+ curwp->w_rflag \|= WFMOVE;
	+
	+ return (compile_goto_error(f, n));
	+}
	+
	+/*
	+ * Since we don't have variables (we probably should) these are command
	+ * processors for changing the values of mode flags.
	+ */
	+/* ARGSUSED */
	+int
	+globalwdtoggle(int f, int n)
	+{
	+ if (f & FFARG)
	+ globalwd = n > 0;
	+ else
	+ globalwd = !globalwd;
	+
	+ sgarbf = TRUE;
	+
	+ return (TRUE);
	+}
	Index: contrib/mg/hash.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/hash.c
	@@ -0,0 +1,709 @@
	+/* DO NOT EDIT
	+ * Automatically generated from term.h */
	+
	+#if HAVE_NBTOOL_CONFIG_H
	+#include "nbtool_config.h"
	+#endif
	+
	+#include <stdint.h>
	+#include <stdlib.h>
	+#include <string.h>
	+
	+#include "term_private.h"
	+#include "terminfo_term.h"
	+
	+#ifndef __arraycount
	+#define __arraycount(__x) (sizeof(__x) / sizeof(__x[0]))
	+#endif
	+
	+extern void mi_vector_hash(const void * __restrict, size_t, uint32_t,
	+ uint32_t[3]);
	+
	+static const char _ti_flagids[][6] = {
	+ "bw",
	+ "am",
	+ "bce",
	+ "ccc",
	+ "xhp",
	+ "xhpa",
	+ "cpix",
	+ "crxm",
	+ "xt",
	+ "xenl",
	+ "eo",
	+ "gn",
	+ "hc",
	+ "chts",
	+ "km",
	+ "daisy",
	+ "hs",
	+ "hls",
	+ "in",
	+ "lpix",
	+ "da",
	+ "db",
	+ "mir",
	+ "msgr",
	+ "nxon",
	+ "xsb",
	+ "npc",
	+ "ndscr",
	+ "nrrmc",
	+ "os",
	+ "mc5i",
	+ "xvpa",
	+ "sam",
	+ "eslok",
	+ "hz",
	+ "ul",
	+ "xon",
	+};
	+
	+#include <stdlib.h>
	+
	+static uint32_t
	+_ti_flaghash(const void * __restrict key, size_t keylen)
	+{
	+ static const uint8_t g[75] = {
	+ 0x13, 0x06, 0x00, 0x17, 0x1f, 0x20, 0x23, 0x00, 0x00, 0x12,
	+ 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x0d, 0x22, 0x00,
	+ 0x00, 0x00, 0x00, 0x0b, 0x00, 0x11, 0x02, 0x03, 0x18, 0x00,
	+ 0x00, 0x00, 0x00, 0x15, 0x00, 0x22, 0x02, 0x09, 0x04, 0x08,
	+ 0x00, 0x00, 0x00, 0x0d, 0x00, 0x1f, 0x22, 0x24, 0x1b, 0x19,
	+ 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00,
	+ 0x00, 0x16, 0x00, 0x18, 0x1d, 0x17, 0x00, 0x00, 0x0f, 0x07,
	+ 0x00, 0x00, 0x00, 0x00, 0x05,
	+ };
	+ uint32_t h[3];
	+
	+ mi_vector_hash(key, keylen, 0x00000000U, h);
	+ return (g[h[0] % 75] + g[h[1] % 75]) % 37;
	+}
	+
	+const char *
	+_ti_flagid(ssize_t idx)
	+{
	+
	+ if ((size_t)idx >= __arraycount(_ti_flagids))
	+ return NULL;
	+ return _ti_flagids[idx];
	+}
	+
	+ssize_t
	+_ti_flagindex(const char *key)
	+{
	+ uint32_t idx;
	+
	+ idx = _ti_flaghash((const unsigned char *)key, strlen(key));
	+ if (idx >= __arraycount(_ti_flagids) \|\|
	+ strcmp(key, _ti_flagids[idx]) != 0)
	+ return -1;
	+ return idx;
	+}
	+
	+static const char _ti_numids[][7] = {
	+ "bitwin",
	+ "bitype",
	+ "bufsz",
	+ "btns",
	+ "cols",
	+ "spinh",
	+ "spinv",
	+ "it",
	+ "lh",
	+ "lw",
	+ "lines",
	+ "lm",
	+ "ma",
	+ "xmc",
	+ "colors",
	+ "maddr",
	+ "mjump",
	+ "pairs",
	+ "wnum",
	+ "mcs",
	+ "mls",
	+ "ncv",
	+ "nlab",
	+ "npins",
	+ "orc",
	+ "orl",
	+ "orhi",
	+ "orvi",
	+ "pb",
	+ "cps",
	+ "vt",
	+ "widcs",
	+ "wsl",
	+};
	+
	+#include <stdlib.h>
	+
	+static uint32_t
	+_ti_numhash(const void * __restrict key, size_t keylen)
	+{
	+ static const uint8_t g[67] = {
	+ 0x0b, 0x01, 0x16, 0x00, 0x00, 0x11, 0x1b, 0x00, 0x00, 0x00,
	+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x1b, 0x01, 0x00, 0x05,
	+ 0x00, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	+ 0x00, 0x18, 0x04, 0x02, 0x00, 0x0f, 0x00, 0x02, 0x1f, 0x06,
	+ 0x15, 0x00, 0x10, 0x0f, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00,
	+ 0x06, 0x00, 0x00, 0x11, 0x0d, 0x1e, 0x19, 0x0a, 0x00, 0x06,
	+ 0x00, 0x04, 0x1c, 0x00, 0x10, 0x00, 0x0c,
	+ };
	+ uint32_t h[3];
	+
	+ mi_vector_hash(key, keylen, 0x00000000U, h);
	+ return (g[h[0] % 67] + g[h[1] % 67]) % 33;
	+}
	+
	+const char *
	+_ti_numid(ssize_t idx)
	+{
	+
	+ if ((size_t)idx >= __arraycount(_ti_numids))
	+ return NULL;
	+ return _ti_numids[idx];
	+}
	+
	+ssize_t
	+_ti_numindex(const char *key)
	+{
	+ uint32_t idx;
	+
	+ idx = _ti_numhash((const unsigned char *)key, strlen(key));
	+ if (idx >= __arraycount(_ti_numids) \|\|
	+ strcmp(key, _ti_numids[idx]) != 0)
	+ return -1;
	+ return idx;
	+}
	+
	+static const char _ti_strids[][9] = {
	+ "acsc",
	+ "scesa",
	+ "cbt",
	+ "bel",
	+ "bicr",
	+ "binel",
	+ "birep",
	+ "cr",
	+ "cpi",
	+ "lpi",
	+ "chr",
	+ "cvr",
	+ "csr",
	+ "rmp",
	+ "csnm",
	+ "tbc",
	+ "mgc",
	+ "clear",
	+ "el1",
	+ "el",
	+ "ed",
	+ "csin",
	+ "colornm",
	+ "hpa",
	+ "cmdch",
	+ "cwin",
	+ "cup",
	+ "cud1",
	+ "home",
	+ "civis",
	+ "cub1",
	+ "mrcup",
	+ "cnorm",
	+ "cuf1",
	+ "ll",
	+ "cuu1",
	+ "cvvis",
	+ "defbi",
	+ "defc",
	+ "dch1",
	+ "dl1",
	+ "devt",
	+ "dial",
	+ "dsl",
	+ "dclk",
	+ "dispc",
	+ "hd",
	+ "enacs",
	+ "endbi",
	+ "smacs",
	+ "smam",
	+ "blink",
	+ "bold",
	+ "smcup",
	+ "smdc",
	+ "dim",
	+ "swidm",
	+ "sdrfq",
	+ "ehhlm",
	+ "smir",
	+ "sitm",
	+ "elhlm",
	+ "slm",
	+ "elohlm",
	+ "smicm",
	+ "snlq",
	+ "snrmq",
	+ "smpch",
	+ "prot",
	+ "rev",
	+ "erhlm",
	+ "smsc",
	+ "invis",
	+ "sshm",
	+ "smso",
	+ "ssubm",
	+ "ssupm",
	+ "ethlm",
	+ "smul",
	+ "sum",
	+ "evhlm",
	+ "smxon",
	+ "ech",
	+ "rmacs",
	+ "rmam",
	+ "sgr0",
	+ "rmcup",
	+ "rmdc",
	+ "rwidm",
	+ "rmir",
	+ "ritm",
	+ "rlm",
	+ "rmicm",
	+ "rmpch",
	+ "rmsc",
	+ "rshm",
	+ "rmso",
	+ "rsubm",
	+ "rsupm",
	+ "rmul",
	+ "rum",
	+ "rmxon",
	+ "pause",
	+ "hook",
	+ "flash",
	+ "ff",
	+ "fsl",
	+ "getm",
	+ "wingo",
	+ "hup",
	+ "is1",
	+ "is2",
	+ "is3",
	+ "if",
	+ "iprog",
	+ "initc",
	+ "initp",
	+ "ich1",
	+ "il1",
	+ "ip",
	+ "ka1",
	+ "ka3",
	+ "kb2",
	+ "kbs",
	+ "kbeg",
	+ "kcbt",
	+ "kc1",
	+ "kc3",
	+ "kcan",
	+ "ktbc",
	+ "kclr",
	+ "kclo",
	+ "kcmd",
	+ "kcpy",
	+ "kcrt",
	+ "kctab",
	+ "kdch1",
	+ "kdl1",
	+ "kcud1",
	+ "krmir",
	+ "kend",
	+ "kent",
	+ "kel",
	+ "ked",
	+ "kext",
	+ "kf0",
	+ "kf1",
	+ "kf2",
	+ "kf3",
	+ "kf4",
	+ "kf5",
	+ "kf6",
	+ "kf7",
	+ "kf8",
	+ "kf9",
	+ "kf10",
	+ "kf11",
	+ "kf12",
	+ "kf13",
	+ "kf14",
	+ "kf15",
	+ "kf16",
	+ "kf17",
	+ "kf18",
	+ "kf19",
	+ "kf20",
	+ "kf21",
	+ "kf22",
	+ "kf23",
	+ "kf24",
	+ "kf25",
	+ "kf26",
	+ "kf27",
	+ "kf28",
	+ "kf29",
	+ "kf30",
	+ "kf31",
	+ "kf32",
	+ "kf33",
	+ "kf34",
	+ "kf35",
	+ "kf36",
	+ "kf37",
	+ "kf38",
	+ "kf39",
	+ "kf40",
	+ "kf41",
	+ "kf42",
	+ "kf43",
	+ "kf44",
	+ "kf45",
	+ "kf46",
	+ "kf47",
	+ "kf48",
	+ "kf49",
	+ "kf50",
	+ "kf51",
	+ "kf52",
	+ "kf53",
	+ "kf54",
	+ "kf55",
	+ "kf56",
	+ "kf57",
	+ "kf58",
	+ "kf59",
	+ "kf60",
	+ "kf61",
	+ "kf62",
	+ "kf63",
	+ "kfnd",
	+ "khlp",
	+ "khome",
	+ "kich1",
	+ "kil1",
	+ "kcub1",
	+ "kll",
	+ "kmrk",
	+ "kmsg",
	+ "kmous",
	+ "kmov",
	+ "knxt",
	+ "knp",
	+ "kopn",
	+ "kopt",
	+ "kpp",
	+ "kprv",
	+ "kprt",
	+ "krdo",
	+ "kref",
	+ "krfr",
	+ "krpl",
	+ "krst",
	+ "kres",
	+ "kcuf1",
	+ "ksav",
	+ "kBEG",
	+ "kCAN",
	+ "kCMD",
	+ "kCPY",
	+ "kCRT",
	+ "kDC",
	+ "kDL",
	+ "kslt",
	+ "kEND",
	+ "kEOL",
	+ "kEXT",
	+ "kind",
	+ "kFND",
	+ "kHLP",
	+ "kHOM",
	+ "kIC",
	+ "kLFT",
	+ "kMSG",
	+ "kMOV",
	+ "kNXT",
	+ "kOPT",
	+ "kPRV",
	+ "kPRT",
	+ "kri",
	+ "kRDO",
	+ "kRPL",
	+ "kRIT",
	+ "kRES",
	+ "kSAV",
	+ "kSPD",
	+ "khts",
	+ "kUND",
	+ "kspd",
	+ "kund",
	+ "kcuu1",
	+ "rmkx",
	+ "smkx",
	+ "lf0",
	+ "lf1",
	+ "lf2",
	+ "lf3",
	+ "lf4",
	+ "lf5",
	+ "lf6",
	+ "lf7",
	+ "lf8",
	+ "lf9",
	+ "lf10",
	+ "fln",
	+ "rmln",
	+ "smln",
	+ "rmm",
	+ "smm",
	+ "mhpa",
	+ "mcud1",
	+ "mcub1",
	+ "mcuf1",
	+ "mvpa",
	+ "mcuu1",
	+ "minfo",
	+ "nel",
	+ "porder",
	+ "oc",
	+ "op",
	+ "pad",
	+ "dch",
	+ "dl",
	+ "cud",
	+ "mcud",
	+ "ich",
	+ "indn",
	+ "il",
	+ "cub",
	+ "mcub",
	+ "cuf",
	+ "mcuf",
	+ "rin",
	+ "cuu",
	+ "mcuu",
	+ "pctrm",
	+ "pfkey",
	+ "pfloc",
	+ "pfxl",
	+ "pfx",
	+ "pln",
	+ "mc0",
	+ "mc5p",
	+ "mc4",
	+ "mc5",
	+ "pulse",
	+ "qdial",
	+ "rmclk",
	+ "rep",
	+ "rfi",
	+ "reqmp",
	+ "rs1",
	+ "rs2",
	+ "rs3",
	+ "rf",
	+ "rc",
	+ "vpa",
	+ "sc",
	+ "scesc",
	+ "ind",
	+ "ri",
	+ "scs",
	+ "s0ds",
	+ "s1ds",
	+ "s2ds",
	+ "s3ds",
	+ "sgr1",
	+ "setab",
	+ "setaf",
	+ "sgr",
	+ "setb",
	+ "smgb",
	+ "smgbp",
	+ "sclk",
	+ "setcolor",
	+ "scp",
	+ "setf",
	+ "smgl",
	+ "smglp",
	+ "smglr",
	+ "slines",
	+ "slength",
	+ "smgr",
	+ "smgrp",
	+ "hts",
	+ "smgtb",
	+ "smgt",
	+ "smgtp",
	+ "wind",
	+ "sbim",
	+ "scsd",
	+ "rbim",
	+ "rcsd",
	+ "subcs",
	+ "supcs",
	+ "ht",
	+ "docr",
	+ "tsl",
	+ "tone",
	+ "u0",
	+ "u1",
	+ "u2",
	+ "u3",
	+ "u4",
	+ "u5",
	+ "u6",
	+ "u7",
	+ "u8",
	+ "u9",
	+ "uc",
	+ "hu",
	+ "wait",
	+ "xoffc",
	+ "xonc",
	+ "zerom",
	+};
	+
	+#include <stdlib.h>
	+
	+static uint32_t
	+_ti_strhash(const void * __restrict key, size_t keylen)
	+{
	+ static const uint16_t g[789] = {
	+ 0x0000, 0x0000, 0x0000, 0x0081, 0x003c, 0x0000, 0x00db, 0x0123,
	+ 0x0000, 0x0045, 0x0000, 0x0000, 0x0000, 0x00b1, 0x0131, 0x0096,
	+ 0x0000, 0x006a, 0x0160, 0x0000, 0x0172, 0x0138, 0x0000, 0x0000,
	+ 0x00a4, 0x00bd, 0x0127, 0x0084, 0x0067, 0x0109, 0x008f, 0x0000,
	+ 0x0000, 0x017c, 0x0000, 0x0053, 0x0156, 0x0000, 0x0000, 0x0000,
	+ 0x00b3, 0x0000, 0x00b9, 0x0096, 0x0058, 0x00b6, 0x00fc, 0x0000,
	+ 0x0058, 0x0000, 0x017d, 0x0000, 0x0006, 0x0000, 0x011f, 0x0000,
	+ 0x0000, 0x00bb, 0x0021, 0x0151, 0x00c7, 0x008c, 0x0000, 0x0058,
	+ 0x008a, 0x011a, 0x0093, 0x0000, 0x0000, 0x0000, 0x013e, 0x0163,
	+ 0x0000, 0x0000, 0x0000, 0x0047, 0x0110, 0x00be, 0x0000, 0x001e,
	+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x00b1, 0x0000, 0x0000,
	+ 0x0000, 0x0000, 0x00c5, 0x0034, 0x0181, 0x00be, 0x0094, 0x0000,
	+ 0x0103, 0x002a, 0x0072, 0x0000, 0x0000, 0x0000, 0x0085, 0x0000,
	+ 0x00d5, 0x0000, 0x0000, 0x0000, 0x00c3, 0x0158, 0x00f6, 0x0000,
	+ 0x00e3, 0x0000, 0x0076, 0x0055, 0x016c, 0x0000, 0x008b, 0x0013,
	+ 0x0000, 0x0000, 0x0183, 0x0000, 0x016a, 0x0152, 0x0183, 0x0013,
	+ 0x0000, 0x0000, 0x0032, 0x0043, 0x006c, 0x012c, 0x0000, 0x0000,
	+ 0x0155, 0x0073, 0x0000, 0x0000, 0x0168, 0x0000, 0x0000, 0x0000,
	+ 0x0078, 0x001b, 0x00d2, 0x0020, 0x0000, 0x0000, 0x0015, 0x0000,
	+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0090, 0x00fb, 0x0007, 0x0000,
	+ 0x0000, 0x00ee, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x00c2,
	+ 0x0095, 0x0034, 0x0089, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
	+ 0x0000, 0x0000, 0x0022, 0x00b9, 0x0173, 0x0157, 0x0000, 0x0000,
	+ 0x0000, 0x0129, 0x0000, 0x000f, 0x0000, 0x0000, 0x0000, 0x0000,
	+ 0x0000, 0x0000, 0x0000, 0x0000, 0x00ef, 0x0000, 0x0000, 0x00a4,
	+ 0x0000, 0x0000, 0x0000, 0x0168, 0x00ec, 0x0000, 0x0000, 0x0000,
	+ 0x0000, 0x016d, 0x0000, 0x0003, 0x0000, 0x0000, 0x0000, 0x0000,
	+ 0x00e3, 0x0000, 0x0000, 0x0000, 0x00d1, 0x0000, 0x0000, 0x006b,
	+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0063,
	+ 0x0000, 0x004b, 0x0175, 0x00ab, 0x011f, 0x0000, 0x0000, 0x003d,
	+ 0x0000, 0x0105, 0x007a, 0x013e, 0x0000, 0x013b, 0x0127, 0x000a,
	+ 0x00ee, 0x0044, 0x0068, 0x013d, 0x008d, 0x0000, 0x0000, 0x0000,
	+ 0x012a, 0x00f8, 0x0077, 0x0000, 0x0000, 0x0048, 0x0000, 0x0155,
	+ 0x0000, 0x0107, 0x0159, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
	+ 0x0000, 0x0073, 0x010f, 0x0166, 0x00fa, 0x0117, 0x0000, 0x0034,
	+ 0x0000, 0x0000, 0x00d0, 0x0000, 0x001d, 0x012f, 0x0000, 0x0000,
	+ 0x017e, 0x0019, 0x0000, 0x0087, 0x0000, 0x0000, 0x013e, 0x013a,
	+ 0x0000, 0x0125, 0x0000, 0x0023, 0x014b, 0x0000, 0x0000, 0x0000,
	+ 0x009d, 0x0133, 0x0000, 0x0000, 0x017d, 0x0000, 0x0000, 0x0000,
	+ 0x0081, 0x0183, 0x0000, 0x0000, 0x0000, 0x00b7, 0x0000, 0x0000,
	+ 0x0000, 0x012a, 0x0112, 0x0000, 0x0000, 0x0102, 0x0000, 0x0074,
	+ 0x0000, 0x0000, 0x012d, 0x0179, 0x00aa, 0x0000, 0x00be, 0x0000,
	+ 0x0000, 0x0164, 0x0161, 0x002c, 0x0030, 0x0000, 0x00ae, 0x013f,
	+ 0x00ba, 0x0075, 0x0000, 0x00bd, 0x0000, 0x0086, 0x0000, 0x0000,
	+ 0x0188, 0x008e, 0x0000, 0x00e1, 0x007f, 0x0000, 0x0116, 0x0000,
	+ 0x0000, 0x0000, 0x011a, 0x015a, 0x0000, 0x00a0, 0x0000, 0x0000,
	+ 0x0000, 0x0000, 0x0076, 0x0000, 0x000d, 0x0044, 0x016e, 0x0000,
	+ 0x0000, 0x0000, 0x0000, 0x0000, 0x011d, 0x00aa, 0x0064, 0x0010,
	+ 0x0000, 0x003e, 0x0000, 0x0000, 0x0117, 0x00a4, 0x0063, 0x0000,
	+ 0x012b, 0x0000, 0x0000, 0x012b, 0x0031, 0x0074, 0x0044, 0x0000,
	+ 0x017f, 0x0017, 0x0179, 0x0041, 0x0000, 0x004c, 0x0041, 0x0000,
	+ 0x0061, 0x000d, 0x0000, 0x0000, 0x0000, 0x0000, 0x0008, 0x0064,
	+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x00a2, 0x0000, 0x00a3,
	+ 0x011b, 0x014e, 0x0000, 0x00be, 0x0000, 0x006e, 0x00d3, 0x0000,
	+ 0x0000, 0x0000, 0x0180, 0x0000, 0x00a1, 0x0000, 0x0000, 0x00e6,
	+ 0x0000, 0x0000, 0x0089, 0x0000, 0x0000, 0x00d0, 0x009f, 0x0032,
	+ 0x0000, 0x0000, 0x00e8, 0x00d9, 0x0000, 0x0002, 0x004b, 0x0000,
	+ 0x0000, 0x0129, 0x0000, 0x016b, 0x0104, 0x0163, 0x0000, 0x0000,
	+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0165, 0x0000,
	+ 0x0000, 0x0000, 0x0155, 0x0017, 0x00c3, 0x0069, 0x0000, 0x00e2,
	+ 0x0000, 0x0000, 0x0000, 0x0092, 0x0000, 0x00b0, 0x0045, 0x0107,
	+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
	+ 0x0103, 0x0000, 0x0000, 0x0000, 0x0034, 0x0000, 0x0130, 0x0000,
	+ 0x0000, 0x00cb, 0x0000, 0x0000, 0x0138, 0x00e7, 0x009a, 0x0000,
	+ 0x0000, 0x0000, 0x0000, 0x0119, 0x0000, 0x0000, 0x0120, 0x0000,
	+ 0x00c0, 0x012a, 0x008e, 0x0000, 0x0012, 0x014a, 0x0000, 0x0000,
	+ 0x0000, 0x009c, 0x0000, 0x00fc, 0x0000, 0x0121, 0x001f, 0x016b,
	+ 0x0000, 0x0000, 0x0021, 0x00fd, 0x0022, 0x00af, 0x0051, 0x0000,
	+ 0x00d6, 0x0000, 0x0000, 0x00d0, 0x010e, 0x0000, 0x0000, 0x00c1,
	+ 0x0159, 0x0000, 0x00b8, 0x0000, 0x0000, 0x010f, 0x0024, 0x0115,
	+ 0x0109, 0x0000, 0x001b, 0x0000, 0x00b5, 0x00d8, 0x0039, 0x00de,
	+ 0x0000, 0x008f, 0x011d, 0x004a, 0x0000, 0x00a5, 0x00ea, 0x0144,
	+ 0x0000, 0x0027, 0x016f, 0x014e, 0x000b, 0x002c, 0x014b, 0x000a,
	+ 0x0046, 0x00b3, 0x00bb, 0x0180, 0x0000, 0x0000, 0x0157, 0x0000,
	+ 0x0057, 0x0000, 0x0000, 0x00d1, 0x0181, 0x00d1, 0x0000, 0x0000,
	+ 0x0000, 0x0000, 0x0078, 0x00e3, 0x0000, 0x0000, 0x0000, 0x0036,
	+ 0x00d0, 0x0000, 0x0000, 0x0000, 0x0065, 0x0140, 0x0000, 0x0000,
	+ 0x0000, 0x006f, 0x00a4, 0x0107, 0x0000, 0x0000, 0x0000, 0x0046,
	+ 0x0000, 0x00b4, 0x015b, 0x0000, 0x004d, 0x0000, 0x0000, 0x0000,
	+ 0x0041, 0x0111, 0x00ff, 0x0000, 0x0000, 0x0000, 0x00a5, 0x0086,
	+ 0x007d, 0x0162, 0x0000, 0x00f5, 0x0000, 0x0080, 0x0079, 0x0000,
	+ 0x0000, 0x0000, 0x0000, 0x00a6, 0x00e7, 0x0172, 0x0000, 0x0000,
	+ 0x00dd, 0x0000, 0x001e, 0x0136, 0x0000, 0x0000, 0x00fb, 0x00e6,
	+ 0x0099, 0x0159, 0x0000, 0x0000, 0x0000, 0x0000, 0x00ff, 0x0000,
	+ 0x0000, 0x014b, 0x0000, 0x0000, 0x0000, 0x000b, 0x0000, 0x0000,
	+ 0x017d, 0x0000, 0x009a, 0x012e, 0x0135, 0x0000, 0x0000, 0x015c,
	+ 0x0171, 0x0000, 0x0000, 0x0036, 0x010f, 0x000b, 0x0171, 0x00f9,
	+ 0x0000, 0x0000, 0x00cb, 0x0000, 0x0000, 0x0000, 0x005a, 0x0091,
	+ 0x0000, 0x0135, 0x004c, 0x0118, 0x0000, 0x0000, 0x0000, 0x0138,
	+ 0x0000, 0x0000, 0x016e, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
	+ 0x0041, 0x0000, 0x00b1, 0x0119, 0x0000, 0x0111, 0x0111, 0x0146,
	+ 0x0059, 0x0005, 0x0000, 0x0000, 0x0186, 0x0000, 0x014a, 0x00df,
	+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x000a, 0x015f,
	+ 0x0000, 0x0000, 0x0000, 0x0163, 0x0000, 0x0000, 0x000c, 0x0000,
	+ 0x0000, 0x00dd, 0x0000, 0x0000, 0x00f9, 0x0000, 0x0000, 0x0164,
	+ 0x0176, 0x00bf, 0x0133, 0x0032, 0x013a, 0x0000, 0x0000, 0x0000,
	+ 0x0000, 0x0088, 0x015d, 0x00b8, 0x0078, 0x005b, 0x0000, 0x0027,
	+ 0x017e, 0x0000, 0x007c, 0x011f, 0x0000, 0x0000, 0x0169, 0x0000,
	+ 0x00f2, 0x0000, 0x00b2, 0x00e1, 0x010d,
	+ };
	+ uint32_t h[3];
	+
	+ mi_vector_hash(key, keylen, 0x00000001U, h);
	+ return (g[h[0] % 789] + g[h[1] % 789]) % 394;
	+}
	+
	+const char *
	+_ti_strid(ssize_t idx)
	+{
	+
	+ if ((size_t)idx >= __arraycount(_ti_strids))
	+ return NULL;
	+ return _ti_strids[idx];
	+}
	+
	+ssize_t
	+_ti_strindex(const char *key)
	+{
	+ uint32_t idx;
	+
	+ idx = _ti_strhash((const unsigned char *)key, strlen(key));
	+ if (idx >= __arraycount(_ti_strids) \|\|
	+ strcmp(key, _ti_strids[idx]) != 0)
	+ return -1;
	+ return idx;
	+}
	Index: contrib/mg/help.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/help.c
	@@ -0,0 +1,235 @@
	+/* $OpenBSD: help.c,v 1.35 2015/03/19 21:22:15 bcallah Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * Help functions for Mg 2
	+ */
	+
	+#include <sys/queue.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <string.h>
	+
	+#include "def.h"
	+#include "funmap.h"
	+#include "kbd.h"
	+#include "key.h"
	+#include "macro.h"
	+
	+static int showall(struct buffer , KEYMAP , char *);
	+static int findbind(KEYMAP , PF, char , size_t);
	+
	+/*
	+ * Read a key from the keyboard, and look it up in the keymap.
	+ * Display the name of the function currently bound to the key.
	+ */
	+/* ARGSUSED */
	+int
	+desckey(int f, int n)
	+{
	+ KEYMAP *curmap;
	+ PF funct;
	+ int c, m, i, num;
	+ char *pep;
	+ char dprompt[80];
	+
	+ if (inmacro)
	+ return (TRUE); /* ignore inside keyboard macro */
	+
	+ num = strlcpy(dprompt, "Describe key briefly: ", sizeof(dprompt));
	+ if (num >= sizeof(dprompt))
	+ num = sizeof(dprompt) - 1;
	+ pep = dprompt + num;
	+ key.k_count = 0;
	+ m = curbp->b_nmodes;
	+ curmap = curbp->b_modes[m]->p_map;
	+ for (;;) {
	+ for (;;) {
	+ ewprintf("%s", dprompt);
	+ pep[-1] = ' ';
	+ pep = getkeyname(pep, sizeof(dprompt) - (pep - dprompt),
	+ key.k_chars[key.k_count++] = c = getkey(FALSE));
	+ if ((funct = doscan(curmap, c, &curmap)) != NULL)
	+ break;
	+ *pep++ = '-';
	+ *pep = '\0';
	+ }
	+ if (funct != rescan)
	+ break;
	+ if (ISUPPER(key.k_chars[key.k_count - 1])) {
	+ funct = doscan(curmap,
	+ TOLOWER(key.k_chars[key.k_count - 1]), &curmap);
	+ if (funct == NULL) {
	+ *pep++ = '-';
	+ *pep = '\0';
	+ continue;
	+ }
	+ if (funct != rescan)
	+ break;
	+ }
	+nextmode:
	+ if (--m < 0)
	+ break;
	+ curmap = curbp->b_modes[m]->p_map;
	+ for (i = 0; i < key.k_count; i++) {
	+ funct = doscan(curmap, key.k_chars[i], &curmap);
	+ if (funct != NULL) {
	+ if (i == key.k_count - 1 && funct != rescan)
	+ goto found;
	+ funct = rescan;
	+ goto nextmode;
	+ }
	+ }
	+ *pep++ = '-';
	+ *pep = '\0';
	+ }
	+found:
	+ if (funct == rescan \|\| funct == selfinsert)
	+ ewprintf("%k is not bound to any function");
	+ else if ((pep = (char *)function_name(funct)) != NULL)
	+ ewprintf("%k runs the command %s", pep);
	+ else
	+ ewprintf("%k is bound to an unnamed function");
	+ return (TRUE);
	+}
	+
	+/*
	+ * This function creates a table, listing all of the command
	+ * keys and their current bindings, and stores the table in the
	+ * help pop-up buffer. This lets Mg produce it's own wall chart.
	+ */
	+/* ARGSUSED */
	+int
	+wallchart(int f, int n)
	+{
	+ int m;
	+ struct buffer *bp;
	+
	+ bp = bfind("help", TRUE);
	+ if (bclear(bp) != TRUE)
	+ /* clear it out */
	+ return (FALSE);
	+ bp->b_flag \|= BFREADONLY;
	+ for (m = curbp->b_nmodes; m > 0; m--) {
	+ if ((addlinef(bp, "Local keybindings for mode %s:",
	+ curbp->b_modes[m]->p_name) == FALSE) \|\|
	+ (showall(bp, curbp->b_modes[m]->p_map, "") == FALSE) \|\|
	+ (addline(bp, "") == FALSE))
	+ return (FALSE);
	+ }
	+ if ((addline(bp, "Global bindings:") == FALSE) \|\|
	+ (showall(bp, fundamental_map, "") == FALSE))
	+ return (FALSE);
	+ return (popbuftop(bp, WNONE));
	+}
	+
	+static int
	+showall(struct buffer bp, KEYMAP map, char *prefix)
	+{
	+ KEYMAP *newmap;
	+ char buf[80], keybuf[16];
	+ PF fun;
	+ int c;
	+
	+ if (addline(bp, "") == FALSE)
	+ return (FALSE);
	+
	+ /* XXX - 256 ? */
	+ for (c = 0; c < 256; c++) {
	+ fun = doscan(map, c, &newmap);
	+ if (fun == rescan \|\| fun == selfinsert)
	+ continue;
	+ getkeyname(buf, sizeof(buf), c);
	+ (void)snprintf(keybuf, sizeof(keybuf), "%s%s ", prefix, buf);
	+ if (fun == NULL) {
	+ if (showall(bp, newmap, keybuf) == FALSE)
	+ return (FALSE);
	+ } else {
	+ if (addlinef(bp, "%-16s%s", keybuf,
	+ function_name(fun)) == FALSE)
	+ return (FALSE);
	+ }
	+ }
	+ return (TRUE);
	+}
	+
	+int
	+help_help(int f, int n)
	+{
	+ KEYMAP *kp;
	+ PF funct;
	+
	+ if ((kp = name_map("help")) == NULL)
	+ return (FALSE);
	+ ewprintf("a b c: ");
	+ do {
	+ funct = doscan(kp, getkey(FALSE), NULL);
	+ } while (funct == NULL \|\| funct == help_help);
	+
	+ if (macrodef && macrocount < MAXMACRO)
	+ macro[macrocount - 1].m_funct = funct;
	+
	+ return ((*funct)(f, n));
	+}
	+
	+/* ARGSUSED */
	+int
	+apropos_command(int f, int n)
	+{
	+ struct buffer *bp;
	+ struct list fnames, el;
	+ char string[32];
	+
	+ if (eread("apropos: ", string, sizeof(string), EFNUL \| EFNEW) == NULL)
	+ return (ABORT);
	+ /* FALSE means we got a 0 character string, which is fine */
	+ bp = bfind("help", TRUE);
	+ if (bclear(bp) == FALSE)
	+ return (FALSE);
	+
	+ fnames = complete_function_list("");
	+ for (el = fnames; el != NULL; el = el->l_next) {
	+ char buf[32];
	+
	+ if (strstr(el->l_name, string) == NULL)
	+ continue;
	+
	+ buf[0] = '\0';
	+ findbind(fundamental_map, name_function(el->l_name),
	+ buf, sizeof(buf));
	+
	+ if (addlinef(bp, "%-32s%s", el->l_name, buf) == FALSE) {
	+ free_file_list(fnames);
	+ return (FALSE);
	+ }
	+ }
	+ free_file_list(fnames);
	+ return (popbuftop(bp, WNONE));
	+}
	+
	+static int
	+findbind(KEYMAP map, PF fun, char buf, size_t len)
	+{
	+ KEYMAP *newmap;
	+ PF nfun;
	+ char buf2[16], keybuf[16];
	+ int c;
	+
	+ /* XXX - 256 ? */
	+ for (c = 0; c < 256; c++) {
	+ nfun = doscan(map, c, &newmap);
	+ if (nfun == fun) {
	+ getkeyname(buf, len, c);
	+ return (TRUE);
	+ }
	+ if (nfun == NULL) {
	+ if (findbind(newmap, fun, buf2, sizeof(buf2)) == TRUE) {
	+ getkeyname(keybuf, sizeof(keybuf), c);
	+ (void)snprintf(buf, len, "%s %s", keybuf, buf2);
	+ return (TRUE);
	+ }
	+ }
	+ }
	+ return (FALSE);
	+}
	Index: contrib/mg/interpreter.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/interpreter.c
	@@ -0,0 +1,979 @@
	+/* $OpenBSD: interpreter.c,v 1.32 2021/05/12 11:13:23 lum Exp $ */
	+/*
	+ * This file is in the public domain.
	+ *
	+ * Author: Mark Lumsden <mark@showcomplex.com>
	+ */
	+
	+/*
	+ * This file attempts to add some 'scripting' functionality into mg.
	+ *
	+ * The initial goal is to give mg the ability to use it's existing functions
	+ * and structures in a linked-up way. Hopefully resulting in user definable
	+ * functions. The syntax is 'scheme' like but currently it is not a scheme
	+ * interpreter.
	+ *
	+ * At the moment there is no manual page reference to this file. The code below
	+ * is liable to change, so use at your own risk!
	+ *
	+ * If you do want to do some testing, you can add some lines to your .mg file
	+ * like:
	+ *
	+ * 1. Give multiple arguments to a function that usually would accept only one:
	+ * (find-file "a.txt" "b.txt" "c.txt")
	+ *
	+ * 2. Define a single value variable:
	+ * (define myfile "d.txt")
	+ *
	+ * 3. Define a list:
	+ * (define myfiles(list "e.txt" "f.txt"))
	+ *
	+ * 4. Use the previously defined variable or list:
	+ * (find-file myfiles)
	+ *
	+ * To do:
	+ * 1. multiline parsing - currently only single lines supported.
	+ * 2. parsing for '(' and ')' throughout whole string and evaluate correctly.
	+ * 3. conditional execution.
	+ * 4. have memory allocated dynamically for variable values.
	+ * 5. do symbol names need more complex regex patterns? [A-Za-z][.0-9_A-Z+a-z-]
	+ * at the moment.
	+ * 6. display line numbers with parsing errors.
	+ * 7. oh so many things....
	+ * [...]
	+ * n. implement user definable functions.
	+ *
	+ * Notes:
	+ * - Currently calls to excline() from this file have the line length and
	+ * line number set to zero.
	+ * That's because excline() uses '\0' as the end of line indicator
	+ * and only the call to foundparen() within excline() uses excline's 2nd
	+ * and 3rd arguments.
	+ * Importantly, any lines sent to there from here will not be
	+ * coming back here.
	+ */
	+#include <sys/queue.h>
	+
	+#include <ctype.h>
	+#include <limits.h>
	+#include <regex.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+
	+#include "def.h"
	+#include "funmap.h"
	+
	+#ifdef MGLOG
	+#include "kbd.h"
	+#include "log.h"
	+#endif
	+
	+static int multiarg(char , char , int);
	+static int isvar(char , char , int);
	+/static int dofunc(char , char , int);/
	+static int founddef(char *, int, int, int, int);
	+static int foundlst(char *, int, int, int);
	+static int expandvals(char , char , char *);
	+static int foundfun(char *, int);
	+static int doregex(char , char );
	+static void clearexp(void);
	+static int parse(char , const char , const char *, int, int, int, int);
	+static int parsdef(char , const char , const char *, int, int, int);
	+static int parsval(char , const char , const char *, int, int, int);
	+static int parsexp(char , const char , const char *, int, int, int);
	+
	+static int exitinterpreter(char , char , int);
	+
	+TAILQ_HEAD(exphead, expentry) ehead;
	+struct expentry {
	+ TAILQ_ENTRY(expentry) eentry;
	+ char fun; / The 1st string found between parens. */
	+ char funbuf[BUFSIZE];
	+ const char par1; / Parenthesis at start of string */
	+ const char par2; / Parenthesis at end of string */
	+ int expctr; /* An incremental counter:+1 for each exp */
	+ int blkid; /* Which block are we in? */
	+};
	+
	+/*
	+ * Structure for scheme keywords.
	+ */
	+#define NUMSCHKEYS 4
	+#define MAXLENSCHKEYS 17 /* 17 = longest keyword (16) + 1 */
	+
	+char scharkey[NUMSCHKEYS][MAXLENSCHKEYS] =
	+ {
	+ "define",
	+ "list",
	+ "if",
	+ "lambda"
	+ };
	+
	+static const char lp = '(';
	+static const char rp = ')';
	+static char *defnam = NULL;
	+static int lnm;
	+
	+/*
	+ * Line has a '(' as the first non-white char.
	+ * Do some very basic parsing of line.
	+ * Multi-line not supported at the moment, To do.
	+ */
	+int
	+foundparen(char *funstr, int llen, int lnum)
	+{
	+ const char *lrp = NULL;
	+ char p, begp = NULL, endp = NULL, prechr;
	+ char *lastchr = NULL;
	+ int i, ret, pctr, expctr, blkid, inquote, esc;
	+ int elen, spc, ns;
	+
	+ pctr = expctr = inquote = esc = elen = spc = ns = 0;
	+ blkid = 1;
	+ lnm = lnum;
	+
	+ /*
	+ * load expressions into a list called 'expentry', to be processd
	+ * when all are obtained.
	+ * Not really live code at the moment. Just part of the process of
	+ * working out what needs to be done.
	+ */
	+ TAILQ_INIT(&ehead);
	+
	+ /*
	+ * Check for blocks of code with opening and closing ().
	+ * One block = (cmd p a r a m)
	+ * Two blocks = (cmd p a r a m s)(hola)
	+ * Two blocks = (cmd p a r (list a m s))(hola)
	+ * Only single line at moment, but more for multiline.
	+ */
	+ p = funstr;
	+
	+ for (i = 0; i < llen; ++i, p++) {
	+ if (pctr == 0 && p != ' ' && p != '\t' && *p != '(') {
	+ if (*p == ')')
	+ return(dobeep_num("Extra ')' found on line:",
	+ lnm));
	+ return(dobeep_num("Error line:", lnm));
	+ }
	+ if (begp != NULL)
	+ elen++;
	+
	+ if (*p == '\\') {
	+ esc = 1;
	+ } else if (*p == '(') {
	+ if (lastchr != NULL && *lastchr == '(')
	+ return(dobeep_num("Multiple consecutive "\
	+ "left parantheses line", lnm));
	+ if (inquote == 0) {
	+ if (begp != NULL) {
	+ if (*prechr == ' ')
	+ ns--;
	+ if (endp == NULL)
	+ *p = '\0';
	+ else
	+ *endp = '\0';
	+
	+ ret = parse(begp, lrp, &lp, blkid,
	+ ++expctr, elen - spc, ns);
	+ if (!ret) {
	+ cleanup();
	+ return(ret);
	+ }
	+ elen = 0;
	+ }
	+ lrp = &lp;
	+ begp = endp = NULL;
	+ pctr++;
	+ } else if (inquote != 1) {
	+ cleanup();
	+ return(dobeep_num("Opening and closing quote "\
	+ "char error line:", lnm));
	+ }
	+ esc = spc = 0;
	+ } else if (*p == ')') {
	+ if (lastchr != NULL && *lastchr == '(')
	+ return(dobeep_num("Empty parenthesis "\
	+ "not supported line", lnm));
	+ if (inquote == 0) {
	+ if (begp != NULL) {
	+ if (*prechr == ' ')
	+ ns--;
	+ if (endp == NULL)
	+ *p = '\0';
	+ else
	+ *endp = '\0';
	+
	+ ret = parse(begp, lrp, &rp, blkid,
	+ ++expctr, elen - spc, ns);
	+ if (!ret) {
	+ cleanup();
	+ return(ret);
	+ }
	+ elen = 0;
	+ }
	+ lrp = &rp;
	+ begp = endp = NULL;
	+ pctr--;
	+ } else if (inquote != 1) {
	+ cleanup();
	+ return(dobeep_num("Opening and closing quote "\
	+ "char error line:", lnm));
	+ }
	+ esc = spc = 0;
	+ } else if (p != ' ' && p != '\t') {
	+ if (begp == NULL) {
	+ begp = p;
	+ if (begp == '"' \|\| isdigit(begp))
	+ return(dobeep_num("First char of "\
	+ "expression error line:", lnm));
	+ }
	+ if (*p == '"') {
	+ if (inquote == 0 && esc == 0) {
	+ if (prechr != ' ' && prechr != '\t')
	+ return(dobeep_num("Parse error"\
	+ " line:", lnm));
	+ inquote++;
	+ } else if (inquote > 0 && esc == 1)
	+ esc = 0;
	+ else
	+ inquote--;
	+ } else if (*prechr == '"' && inquote == 0) {
	+ return(dobeep_num("Parse error line:", lnm));
	+ }
	+ endp = NULL;
	+ spc = 0;
	+ } else if (endp == NULL && (p == ' ' \|\| p == '\t')) {
	+ if (inquote == 0) {
	+ *p = ' ';
	+ endp = p;
	+ spc++;
	+ if (begp != NULL)
	+ ns++;
	+ }
	+ esc = 0;
	+ } else if (p == '\t' \|\| p == ' ') {
	+ if (inquote == 0) {
	+ *p = ' ';
	+ spc++;
	+ }
	+ esc = 0;
	+ }
	+ if (p != '\t' && p != ' ' && inquote == 0)
	+ lastchr = p;
	+
	+ if (pctr == 0) {
	+ blkid++;
	+ expctr = 0;
	+ defnam = NULL;
	+ }
	+ prechr = p;
	+ }
	+
	+ if (pctr != 0) {
	+ cleanup();
	+ return(dobeep_num("Opening and closing parentheses error line:",
	+ lnm));
	+ }
	+ if (ret == FALSE)
	+ cleanup();
	+ else
	+ clearexp(); /* leave lists but remove expressions */
	+
	+ return (ret);
	+}
	+
	+
	+static int
	+parse(char begp, const char par1, const char *par2, int blkid, int expctr,
	+ int elen, int ns)
	+{
	+ char *regs;
	+ int ret = FALSE;
	+
	+ if (strncmp(begp, "define", 6) == 0) {
	+ ret = parsdef(begp, par1, par2, blkid, expctr, elen);
	+ if (ret == TRUE \|\| ret == FALSE)
	+ return (ret);
	+ } else if (strncmp(begp, "list", 4) == 0)
	+ return(parsval(begp, par1, par2, blkid, expctr, elen));
	+
	+ regs = "^exit$";
	+ if (doregex(regs, begp))
	+ return(exitinterpreter(NULL, NULL, FALSE));
	+
	+ /* mg function name regex */
	+ regs = "^[A-Za-z-]+$";
	+ if (doregex(regs, begp))
	+ return(excline(begp, 0, 0));
	+
	+ /* Corner case 1 */
	+ if (strncmp(begp, "global-set-key ", 15) == 0)
	+ /* function name as 2nd param screws up multiarg. */
	+ return(excline(begp, 0, 0));
	+
	+ /* Corner case 2 */
	+ if (strncmp(begp, "define-key ", 11) == 0)
	+ /* function name as 3rd param screws up multiarg. */
	+ return(excline(begp, 0, 0));
	+
	+ return (parsexp(begp, par1, par2, blkid, expctr, elen));
	+}
	+
	+static int
	+parsdef(char begp, const char par1, const char *par2, int blkid, int expctr,
	+ int elen)
	+{
	+ char *regs;
	+
	+ if ((defnam == NULL) && (expctr != 1))
	+ return(dobeep_num("'define' incorrectly used line:", lnm));
	+
	+ /* Does the line have a incorrect variable 'define' like: */
	+ /* (define i y z) */
	+ regs = "^define[ ]+[A-Za-z][.0-9_A-Z+a-z-]*[ ]+.+[ ]+.+$";
	+ if (doregex(regs, begp))
	+ return(dobeep_num("Invalid use of define line:", lnm));
	+
	+ /* Does the line have a single variable 'define' like: */
	+ /* (define i 0) */
	+ regs = "^define[ ]+[A-Za-z][.0-9_A-Z+a-z-][ ]+.$";
	+ if (doregex(regs, begp)) {
	+ if (par1 == &lp && par2 == &rp && expctr == 1)
	+ return(founddef(begp, blkid, expctr, 1, elen));
	+ return(dobeep_num("Invalid use of define line:", lnm));
	+ }
	+ /* Does the line have '(define i(' */
	+ regs = "^define[ ]+[A-Za-z][.0-9_A-Z+a-z-][ ]$";
	+ if (doregex(regs, begp)) {
	+ if (par1 == &lp && par2 == &lp && expctr == 1)
	+ return(founddef(begp, blkid, expctr, 0, elen));
	+ return(dobeep_num("Invalid use of 'define' line:", lnm));
	+ }
	+ /* Does the line have '(define (' */
	+ regs = "^define$";
	+ if (doregex(regs, begp)) {
	+ if (par1 == &lp && par2 == &lp && expctr == 1)
	+ return(foundfun(begp, expctr));
	+ return(dobeep_num("Invalid use of 'define' line:", lnm));
	+ }
	+
	+ return (ABORT);
	+}
	+
	+static int
	+parsval(char begp, const char par1, const char *par2, int blkid, int expctr,
	+ int elen)
	+{
	+ char *regs;
	+
	+ /* Does the line have 'list' */
	+ regs = "^list$";
	+ if (doregex(regs, begp))
	+ return(dobeep_num("Invalid use of list line:", lnm));
	+
	+ /* Does the line have a 'list' like: */
	+ /* (list "a" "b") */
	+ regs = "^list[ ]+.*$";
	+ if (doregex(regs, begp)) {
	+ if (expctr == 1)
	+ return(dobeep_num("list with no-where to go.", lnm));
	+
	+ if (par1 == &lp && expctr > 1)
	+ return(foundlst(begp, blkid, expctr, elen));
	+
	+ return(dobeep_num("Invalid use of list line:", lnm));
	+ }
	+ return (FALSE);
	+}
	+
	+static int
	+parsexp(char begp, const char par1, const char *par2, int blkid, int expctr,
	+ int elen)
	+{
	+ struct expentry *e1 = NULL;
	+ PF funcp;
	+ char cmdp, fendp, valp, fname, *funb = NULL;;
	+ int numparams, ret;
	+
	+ cmdp = begp;
	+ fendp = strchr(cmdp, ' ');
	+ *fendp = '\0';
	+
	+ /*
	+ * If no extant mg command found, just return.
	+ */
	+ if ((funcp = name_function(cmdp)) == NULL)
	+ return (dobeep_msgs("Unknown command: ", cmdp));
	+
	+ numparams = numparams_function(funcp);
	+ if (numparams == 0)
	+ return (dobeep_msgs("Command takes no arguments:", cmdp));
	+
	+ if (numparams == -1)
	+ return (dobeep_msgs("Interactive command found:", cmdp));
	+
	+ if ((e1 = malloc(sizeof(struct expentry))) == NULL) {
	+ cleanup();
	+ return (dobeep_msg("malloc Error"));
	+ }
	+ TAILQ_INSERT_HEAD(&ehead, e1, eentry);
	+ if ((e1->fun = strndup(cmdp, BUFSIZE)) == NULL) {
	+ cleanup();
	+ return(dobeep_msg("strndup error"));
	+ }
	+ cmdp = e1->fun;
	+ fname = e1->fun;
	+ e1->funbuf[0] = '\0';
	+ funb = e1->funbuf;
	+ e1->expctr = expctr;
	+ e1->blkid = blkid;
	+ /* need to think about these two */
	+ e1->par1 = par1;
	+ e1->par2 = par2;
	+
	+ *fendp = ' ';
	+ valp = fendp + 1;
	+
	+ ret = expandvals(cmdp, valp, funb);
	+ if (!ret)
	+ return (ret);
	+
	+ return (multiarg(fname, funb, numparams));
	+}
	+
	+/*
	+ * Pass a list of arguments to a function.
	+ */
	+static int
	+multiarg(char cmdp, char argbuf, int numparams)
	+{
	+ char excbuf[BUFSIZE];
	+ char argp, p, *s = " ";
	+ char *regs;
	+ int spc, numspc;
	+ int fin, inquote;
	+
	+ argp = argbuf;
	+ spc = 1; /* initially fake a space so we find first argument */
	+ numspc = fin = inquote = 0;
	+
	+ for (p = argbuf; *p != '\0'; p++) {
	+ if (*(p + 1) == '\0')
	+ fin = 1;
	+
	+ if (*p != ' ') {
	+ if (*p == '"') {
	+ if (inquote == 1)
	+ inquote = 0;
	+ else
	+ inquote = 1;
	+ }
	+ if (spc == 1)
	+ if ((numspc % numparams) == 0) {
	+ argp = p;
	+ }
	+ spc = 0;
	+ }
	+ if ((*p == ' ' && inquote == 0) \|\| fin) {
	+ if (spc == 1)/* \|\| (numspc % numparams == 0))*/
	+ continue;
	+ if ((numspc % numparams) != (numparams - 1)) {
	+ numspc++;
	+ continue;
	+ }
	+ if (*p == ' ') {
	+ p = '\0'; / terminate arg string */
	+ }
	+ excbuf[0] = '\0';
	+ regs = "[\"]+.*[\"]+";
	+
	+ if (!doregex(regs, argp)) {
	+ const char *errstr;
	+ int iters;
	+
	+ iters = strtonum(argp, 0, INT_MAX, &errstr);
	+ if (errstr != NULL)
	+ return (dobeep_msgs("Var not found:",
	+ argp));
	+ }
	+
	+ if (strlcpy(excbuf, cmdp, sizeof(excbuf))
	+ >= sizeof(excbuf))
	+ return (dobeep_msg("strlcpy error"));
	+ if (strlcat(excbuf, s, sizeof(excbuf))
	+ >= sizeof(excbuf))
	+ return (dobeep_msg("strlcat error"));
	+ if (strlcat(excbuf, argp, sizeof(excbuf))
	+ >= sizeof(excbuf))
	+ return (dobeep_msg("strlcat error"));
	+
	+ excline(excbuf, 0, 0);
	+
	+ if (fin)
	+ break;
	+
	+ p = ' '; / unterminate arg string */
	+ numspc++;
	+ spc = 1;
	+ }
	+ }
	+ return (TRUE);
	+}
	+
	+/*
	+ * Is an item a value or a variable?
	+ */
	+static int
	+isvar(char argp, char varbuf, int sizof)
	+{
	+ struct varentry *v1 = NULL;
	+
	+ if (SLIST_EMPTY(&varhead))
	+ return (FALSE);
	+#ifdef MGLOG
	+ mglog_isvar(varbuf, argp, sizof);
	+#endif
	+ SLIST_FOREACH(v1, &varhead, entry) {
	+ if (strcmp(*argp, v1->v_name) == 0) {
	+ (void)(strlcpy(*varbuf, v1->v_buf, sizof) >= sizof);
	+ return (TRUE);
	+ }
	+ }
	+ return (FALSE);
	+}
	+
	+
	+static int
	+foundfun(char *defstr, int expctr)
	+{
	+ return (TRUE);
	+}
	+
	+static int
	+foundlst(char *defstr, int blkid, int expctr, int elen)
	+{
	+ char *p;
	+
	+ p = strstr(defstr, " ");
	+ p = skipwhite(p);
	+ expandvals(NULL, p, defnam);
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * 'define' strings follow the regex in parsdef().
	+ */
	+static int
	+founddef(char *defstr, int blkid, int expctr, int hasval, int elen)
	+{
	+ struct varentry vt, v1 = NULL;
	+ char p, vnamep, vendp = NULL, valp;
	+
	+ p = strstr(defstr, " "); /* move to first ' ' char. */
	+ vnamep = skipwhite(p); /* find first char of var name. */
	+ vendp = vnamep;
	+
	+ /* now find the end of the define/list name */
	+ while (1) {
	+ ++vendp;
	+ if (*vendp == ' ')
	+ break;
	+ }
	+ *vendp = '\0';
	+
	+ /*
	+ * Check list name is not an existing mg function.
	+ */
	+ if (name_function(vnamep) != NULL)
	+ return(dobeep_msgs("Variable/function name clash:", vnamep));
	+
	+ if (!SLIST_EMPTY(&varhead)) {
	+ SLIST_FOREACH_SAFE(v1, &varhead, entry, vt) {
	+ if (strcmp(vnamep, v1->v_name) == 0)
	+ SLIST_REMOVE(&varhead, v1, varentry, entry);
	+ }
	+ }
	+ if ((v1 = malloc(sizeof(struct varentry))) == NULL)
	+ return (ABORT);
	+ SLIST_INSERT_HEAD(&varhead, v1, entry);
	+ if ((v1->v_name = strndup(vnamep, BUFSIZE)) == NULL)
	+ return(dobeep_msg("strndup error"));
	+ vnamep = v1->v_name;
	+ v1->v_count = 0;
	+ v1->v_vals = NULL;
	+ v1->v_buf[0] = '\0';
	+
	+ defnam = v1->v_buf;
	+
	+ if (hasval) {
	+ valp = skipwhite(vendp + 1);
	+
	+ expandvals(NULL, valp, defnam);
	+ defnam = NULL;
	+ }
	+ *vendp = ' ';
	+ return (TRUE);
	+}
	+
	+
	+static int
	+expandvals(char cmdp, char valp, char *bp)
	+{
	+ char excbuf[BUFSIZE], argbuf[BUFSIZE];
	+ char contbuf[BUFSIZE], varbuf[BUFSIZE];
	+ char argp, endp, p, v, *s = " ";
	+ char *regs;
	+ int spc, cnt;
	+ int inlist, sizof, fin, inquote;
	+
	+ /* now find the first argument */
	+ p = skipwhite(valp);
	+
	+ if (strlcpy(argbuf, p, sizeof(argbuf)) >= sizeof(argbuf))
	+ return (dobeep_msg("strlcpy error"));
	+ argp = argbuf;
	+ spc = 1; /* initially fake a space so we find first argument */
	+ inlist = fin = inquote = cnt = spc = 0;
	+
	+ for (p = argbuf; *p != '\0'; p++) {
	+ if (*(p + 1) == '\0')
	+ fin = 1;
	+
	+ if (*p != ' ') {
	+ if (*p == '"') {
	+ if (inquote == 1)
	+ inquote = 0;
	+ else
	+ inquote = 1;
	+ }
	+ if (spc == 1)
	+ argp = p;
	+ spc = 0;
	+ }
	+ if ((*p == ' ' && inquote == 0) \|\| fin) {
	+ if (spc == 1)
	+ continue;
	+ /* terminate arg string */
	+ if (*p == ' ') {
	+ *p = '\0';
	+ }
	+ endp = p + 1;
	+ excbuf[0] = '\0';
	+ varbuf[0] = '\0';
	+ contbuf[0] = '\0';
	+ sizof = sizeof(varbuf);
	+ v = varbuf;
	+ regs = "[\"]+.*[\"]+";
	+ if (doregex(regs, argp))
	+ ; /* found quotes */
	+ else if (isvar(&argp, &v, sizof)) {
	+
	+ (void)(strlcat(varbuf, " ",
	+ sizof) >= sizof);
	+
	+ *p = ' ';
	+ (void)(strlcpy(contbuf, endp,
	+ sizeof(contbuf)) >= sizeof(contbuf));
	+
	+ (void)(strlcat(varbuf, contbuf,
	+ sizof) >= sizof);
	+
	+ argbuf[0] = ' ';
	+ argbuf[1] = '\0';
	+ (void)(strlcat(argbuf, varbuf,
	+ sizof) >= sizof);
	+
	+ p = argp = argbuf;
	+ spc = 1;
	+ fin = 0;
	+ continue;
	+ } else {
	+ const char *errstr;
	+ int iters;
	+
	+ iters = strtonum(argp, 0, INT_MAX, &errstr);
	+ if (errstr != NULL)
	+ return (dobeep_msgs("Var not found:",
	+ argp));
	+ }
	+#ifdef MGLOG
	+ mglog_misc("x\|%s\|%p\|%d\|\n", bp, defnam, BUFSIZE);
	+#endif
	+ if (*bp != '\0') {
	+ if (strlcat(bp, s, BUFSIZE) >= BUFSIZE)
	+ return (dobeep_msg("strlcat error"));
	+ }
	+ if (strlcat(bp, argp, BUFSIZE) >= BUFSIZE) {
	+ return (dobeep_msg("strlcat error"));
	+ }
	+/* v1->v_count++;*/
	+
	+ if (fin)
	+ break;
	+
	+ p = ' '; / unterminate arg string */
	+ spc = 1;
	+ }
	+ }
	+ return (TRUE);
	+}
	+
	+/*
	+ * Finished with buffer evaluation, so clean up any vars.
	+ * Perhaps keeps them in mg even after use,...
	+ */
	+/*static int
	+clearvars(void)
	+{
	+ struct varentry *v1 = NULL;
	+
	+ while (!SLIST_EMPTY(&varhead)) {
	+ v1 = SLIST_FIRST(&varhead);
	+ SLIST_REMOVE_HEAD(&varhead, entry);
	+ free(v1->v_name);
	+ free(v1);
	+ }
	+ return (FALSE);
	+}
	+*/
	+/*
	+ * Finished with block evaluation, so clean up any expressions.
	+ */
	+static void
	+clearexp(void)
	+{
	+ struct expentry *e1 = NULL;
	+
	+ while (!TAILQ_EMPTY(&ehead)) {
	+ e1 = TAILQ_FIRST(&ehead);
	+ TAILQ_REMOVE(&ehead, e1, eentry);
	+ free(e1->fun);
	+ free(e1);
	+ }
	+ return;
	+}
	+
	+/*
	+ * Cleanup before leaving.
	+ */
	+void
	+cleanup(void)
	+{
	+ defnam = NULL;
	+
	+ clearexp();
	+/* clearvars();*/
	+}
	+
	+/*
	+ * Test a string against a regular expression.
	+ */
	+static int
	+doregex(char r, char e)
	+{
	+ regex_t regex_buff;
	+
	+ if (regcomp(&regex_buff, r, REG_EXTENDED)) {
	+ regfree(&regex_buff);
	+ return(dobeep_num("Regex compilation error line:", lnm));
	+ }
	+ if (!regexec(&regex_buff, e, 0, NULL, 0)) {
	+ regfree(&regex_buff);
	+ return(TRUE);
	+ }
	+ regfree(&regex_buff);
	+ return(FALSE);
	+}
	+
	+/*
	+ * Display a message so it is apparent that this is the method which stopped
	+ * execution.
	+ */
	+static int
	+exitinterpreter(char ptr, char dobuf, int dosiz)
	+{
	+ cleanup();
	+ if (batch == 0)
	+ return(dobeep_msg("Interpreter exited via exit command."));
	+ return(FALSE);
	+}
	+
	+/*
	+ * All code below commented out (until end of file).
	+ *
	+ * Need to think about how interpreter functions are done.
	+ * Probably don't have a choice with string-append().
	+
	+static int getenvironmentvariable(char , char , int);
	+static int stringappend(char , char , int);
	+
	+typedef int (PFI)(char , char *, int);
	+
	+
	+struct ifunmap {
	+ PFI fn_funct;
	+ const char *fn_name;
	+ struct ifunmap *fn_next;
	+};
	+static struct ifunmap *ifuns;
	+
	+static struct ifunmap ifunctnames[] = {
	+ {exitinterpreter, "exit"},
	+ {getenvironmentvariable, "get-environment-variable"},
	+ {stringappend, "string-append"},
	+ {NULL, NULL}
	+};
	+
	+void
	+ifunmap_init(void)
	+{
	+ struct ifunmap *fn;
	+
	+ for (fn = ifunctnames; fn->fn_name != NULL; fn++) {
	+ fn->fn_next = ifuns;
	+ ifuns = fn;
	+ }
	+}
	+
	+PFI
	+name_ifun(const char *ifname)
	+{
	+ struct ifunmap *fn;
	+
	+ for (fn = ifuns; fn != NULL; fn = fn->fn_next) {
	+ if (strcmp(fn->fn_name, ifname) == 0)
	+ return (fn->fn_funct);
	+ }
	+
	+ return (NULL);
	+}
	+
	+
	+int
	+dofunc(char ifname, char tmpbuf, int sizof)
	+{
	+ PFI fnc;
	+ char p, tmp;
	+
	+ p = strstr(*ifname, " ");
	+ *p = '\0';
	+
	+ fnc = name_ifun(*ifname);
	+ if (fnc == NULL)
	+ return (FALSE);
	+
	+ *p = ' ';
	+
	+ tmp = *tmpbuf;
	+
	+ fnc(p, tmp, sizof);
	+
	+ return (TRUE);
	+}
	+
	+static int
	+getenvironmentvariable(char ptr, char dobuf, int dosiz)
	+{
	+ char *t;
	+ char *tmp;
	+ const char *q = "\"";
	+
	+ t = skipwhite(ptr);
	+
	+ if (t[0] == q \|\| t[strlen(t) - 1] == q)
	+ return (dobeep_msgs("Please remove '\"' around:", t));
	+ if ((tmp = getenv(t)) == NULL \|\| *tmp == '\0')
	+ return(dobeep_msgs("Envar not found:", t));
	+
	+ dobuf[0] = '\0';
	+ if (strlcat(dobuf, q, dosiz) >= dosiz)
	+ return (dobeep_msg("strlcat error"));
	+ if (strlcat(dobuf, tmp, dosiz) >= dosiz)
	+ return (dobeep_msg("strlcat error"));
	+ if (strlcat(dobuf, q, dosiz) >= dosiz)
	+ return (dobeep_msg("strlcat error"));
	+
	+ return (TRUE);
	+}
	+
	+static int
	+stringappend(char ptr, char dobuf, int dosiz)
	+{
	+ char varbuf[BUFSIZE], funbuf[BUFSIZE];
	+ char p, f, v, vendp;
	+ int sizof, fin = 0;
	+
	+ varbuf[0] = funbuf[0] = '\0';
	+ f = funbuf;
	+ v = varbuf;
	+ sizof = sizeof(varbuf);
	+ *dobuf = '\0';
	+
	+ p = skipwhite(ptr);
	+
	+ while (*p != '\0') {
	+ vendp = p;
	+ while (1) {
	+ if (*vendp == ' ') {
	+ break;
	+ } else if (*vendp == '\0') {
	+ fin = 1;
	+ break;
	+ }
	+ ++vendp;
	+ }
	+ *vendp = '\0';
	+
	+ if (isvar(&p, &v, sizof)) {
	+ if (v[0] == '"' && v[strlen(v) - 1] == '"' ) {
	+ v[strlen(v) - 1] = '\0';
	+ v = v + 1;
	+ }
	+ if (strlcat(f, v, sizof) >= sizof)
	+ return (dobeep_msg("strlcat error"));
	+ } else {
	+ if (p[0] == '"' && p[strlen(p) - 1] == '"' ) {
	+ p[strlen(p) - 1] = '\0';
	+ p = p + 1;
	+ }
	+ if (strlcat(f, p, sizof) >= sizof)
	+ return (dobeep_msg("strlcat error"));
	+ }
	+ if (fin)
	+ break;
	+ vendp++;
	+ if (*vendp == '\0')
	+ break;
	+ p = skipwhite(vendp);
	+ }
	+
	+ (void)snprintf(dobuf, dosiz, "\"%s\"", f);
	+
	+ return (TRUE);
	+}
	+
	+Index: main.c
	+===================================================================
	+RCS file: /cvs/src/usr.bin/mg/main.c,v
	+retrieving revision 1.89
	+diff -u -p -u -p -r1.89 main.c
	+--- main.c 20 Mar 2021 09:00:49 -0000 1.89
	++++ main.c 12 Apr 2021 17:58:52 -0000
	+@@ -133,10 +133,12 @@ main(int argc, char **argv)
	+ extern void grep_init(void);
	+ extern void cmode_init(void);
	+ extern void dired_init(void);
	++ extern void ifunmap_init(void);
	+
	+ dired_init();
	+ grep_init();
	+ cmode_init();
	++ ifunmap_init();
	+ }
	+
	+
	+*/
	Index: contrib/mg/kbd.h
	===================================================================
	--- /dev/null
	+++ contrib/mg/kbd.h
	@@ -0,0 +1,57 @@
	+/* $OpenBSD: kbd.h,v 1.19 2015/03/19 21:48:05 bcallah Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * kbd.h: type definitions for symbol.c and kbd.c for mg experimental
	+ */
	+
	+struct map_element {
	+ KCHAR k_base; /* first key in element */
	+ KCHAR k_num; /* last key in element */
	+ PF k_funcp; / pointer to array of pointers */
	+ /* to functions */
	+ struct keymap_s k_prefmap; / keymap of ONLY prefix key in */
	+ /* element */
	+};
	+
	+/*
	+ * Predefined keymaps are NOT type KEYMAP because final array needs
	+ * dimension. If any changes are made to this struct, they must be reflected
	+ * in all keymap declarations.
	+ */
	+
	+#define KEYMAPE(NUM) { \
	+ short map_num; /* elements used */ \
	+ short map_max; /* elements allocated */\
	+ PF map_default; /* default function */ \
	+ struct map_element map_element[NUM]; /* really [e_max] */ \
	+}
	+typedef struct keymap_s KEYMAPE(1) KEYMAP;
	+
	+/* Number of map_elements to grow an overflowed keymap by */
	+#define MAPGROW 3
	+#define MAPINIT (MAPGROW+1)
	+
	+/* Max number of default bindings added to avoid creating new element */
	+#define MAPELEDEF 4
	+
	+struct maps_s {
	+ KEYMAP *p_map;
	+ const char *p_name;
	+ struct maps_s *p_next;
	+};
	+
	+extern struct maps_s *maps;
	+extern struct maps_s fundamental_mode;
	+#define fundamental_map (fundamental_mode.p_map)
	+
	+int dobindkey(KEYMAP , const char , const char *);
	+KEYMAP name_map(const char );
	+struct maps_s name_mode(const char );
	+PF doscan(KEYMAP , int, KEYMAP *);
	+void maps_init(void);
	+int maps_add(KEYMAP , const char );
	+
	+extern struct map_element *ele;
	+extern struct maps_s *defb_modes[];
	Index: contrib/mg/kbd.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/kbd.c
	@@ -0,0 +1,462 @@
	+/* $OpenBSD: kbd.c,v 1.35 2021/03/01 10:51:14 lum Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * Terminal independent keyboard handling.
	+ */
	+
	+#include <sys/queue.h>
	+#include <signal.h>
	+#include <stdio.h>
	+
	+#include "def.h"
	+#include "kbd.h"
	+#include "key.h"
	+#include "macro.h"
	+
	+#ifdef MGLOG
	+#include "log.h"
	+#endif
	+
	+#define METABIT 0x80
	+
	+#define PROMPTL 80
	+char prompt[PROMPTL] = "", *promptp = prompt;
	+
	+static int mgwrap(PF, int, int);
	+
	+static int use_metakey = TRUE;
	+static int pushed = FALSE;
	+static int pushedc;
	+
	+struct map_element *ele;
	+struct key key;
	+int rptcount;
	+
	+/*
	+ * Toggle the value of use_metakey
	+ */
	+int
	+do_meta(int f, int n)
	+{
	+ if (f & FFARG)
	+ use_metakey = n > 0;
	+ else
	+ use_metakey = !use_metakey;
	+ ewprintf("Meta keys %sabled", use_metakey ? "en" : "dis");
	+ return (TRUE);
	+}
	+
	+static int bs_map = 0;
	+
	+/*
	+ * Toggle backspace mapping
	+ */
	+int
	+bsmap(int f, int n)
	+{
	+ if (f & FFARG)
	+ bs_map = n > 0;
	+ else
	+ bs_map = !bs_map;
	+ ewprintf("Backspace mapping %sabled", bs_map ? "en" : "dis");
	+ return (TRUE);
	+}
	+
	+void
	+ungetkey(int c)
	+{
	+ if (use_metakey && pushed && c == CCHR('['))
	+ pushedc \|= METABIT;
	+ else
	+ pushedc = c;
	+ pushed = TRUE;
	+}
	+
	+int
	+getkey(int flag)
	+{
	+ int c;
	+
	+ if (flag && !pushed) {
	+ if (prompt[0] != '\0' && ttwait(2000)) {
	+ /* avoid problems with % */
	+ ewprintf("%s", prompt);
	+ /* put the cursor back */
	+ update(CMODE);
	+ epresf = KCLEAR;
	+ }
	+ if (promptp > prompt)
	+ *(promptp - 1) = ' ';
	+ }
	+ if (pushed) {
	+ c = pushedc;
	+ pushed = FALSE;
	+ } else
	+ c = ttgetc();
	+
	+ if (bs_map) {
	+ if (c == CCHR('H'))
	+ c = CCHR('?');
	+ else if (c == CCHR('?'))
	+ c = CCHR('H');
	+ }
	+ if (use_metakey && (c & METABIT)) {
	+ pushedc = c & ~METABIT;
	+ pushed = TRUE;
	+ c = CCHR('[');
	+ }
	+ if (flag && promptp < &prompt[PROMPTL - 5]) {
	+ promptp = getkeyname(promptp,
	+ sizeof(prompt) - (promptp - prompt) - 1, c);
	+ *promptp++ = '-';
	+ *promptp = '\0';
	+ }
	+ return (c);
	+}
	+
	+/*
	+ * doscan scans a keymap for a keyboard character and returns a pointer
	+ * to the function associated with that character. Sets ele to the
	+ * keymap element the keyboard was found in as a side effect.
	+ */
	+PF
	+doscan(KEYMAP map, int c, KEYMAP *newmap)
	+{
	+ struct map_element *elec = &map->map_element[0];
	+ struct map_element *last = &map->map_element[map->map_num];
	+ PF ret;
	+
	+ while (elec < last && c > elec->k_num)
	+ elec++;
	+
	+ /* used by prefix and binding code */
	+ ele = elec;
	+ if (elec >= last \|\| c < elec->k_base)
	+ ret = map->map_default;
	+ else
	+ ret = elec->k_funcp[c - elec->k_base];
	+ if (ret == NULL && newmap != NULL)
	+ *newmap = elec->k_prefmap;
	+
	+ return (ret);
	+}
	+
	+int
	+doin(void)
	+{
	+ KEYMAP *curmap;
	+ PF funct;
	+
	+ *(promptp = prompt) = '\0';
	+ curmap = curbp->b_modes[curbp->b_nmodes]->p_map;
	+ key.k_count = 0;
	+ while ((funct = doscan(curmap, (key.k_chars[key.k_count++] =
	+ getkey(TRUE)), &curmap)) == NULL)
	+ /* nothing */;
	+
	+#ifdef MGLOG
	+ if (!mglog(funct, curmap))
	+ ewprintf("Problem with logging");
	+#endif
	+
	+ if (macrodef && macrocount < MAXMACRO)
	+ macro[macrocount++].m_funct = funct;
	+
	+ return (mgwrap(funct, 0, 1));
	+}
	+
	+int
	+rescan(int f, int n)
	+{
	+ int c;
	+ KEYMAP *curmap;
	+ int i;
	+ PF fp = NULL;
	+ int md = curbp->b_nmodes;
	+
	+ for (;;) {
	+ if (ISUPPER(key.k_chars[key.k_count - 1])) {
	+ c = TOLOWER(key.k_chars[key.k_count - 1]);
	+ curmap = curbp->b_modes[md]->p_map;
	+ for (i = 0; i < key.k_count - 1; i++) {
	+ if ((fp = doscan(curmap, (key.k_chars[i]),
	+ &curmap)) != NULL)
	+ break;
	+ }
	+ if (fp == NULL) {
	+ if ((fp = doscan(curmap, c, NULL)) == NULL)
	+ while ((fp = doscan(curmap,
	+ key.k_chars[key.k_count++] =
	+ getkey(TRUE), &curmap)) == NULL)
	+ /* nothing */;
	+ if (fp != rescan) {
	+ if (macrodef && macrocount <= MAXMACRO)
	+ macro[macrocount - 1].m_funct
	+ = fp;
	+ return (mgwrap(fp, f, n));
	+ }
	+ }
	+ }
	+ /* try previous mode */
	+ if (--md < 0)
	+ return (ABORT);
	+ curmap = curbp->b_modes[md]->p_map;
	+ for (i = 0; i < key.k_count; i++) {
	+ if ((fp = doscan(curmap, (key.k_chars[i]), &curmap)) != NULL)
	+ break;
	+ }
	+ if (fp == NULL) {
	+ while ((fp = doscan(curmap, key.k_chars[i++] =
	+ getkey(TRUE), &curmap)) == NULL)
	+ /* nothing */;
	+ key.k_count = i;
	+ }
	+ if (fp != rescan && i >= key.k_count - 1) {
	+ if (macrodef && macrocount <= MAXMACRO)
	+ macro[macrocount - 1].m_funct = fp;
	+ return (mgwrap(fp, f, n));
	+ }
	+ }
	+}
	+
	+int
	+universal_argument(int f, int n)
	+{
	+ KEYMAP *curmap;
	+ PF funct;
	+ int c, nn = 4;
	+
	+ if (f & FFUNIV)
	+ nn *= n;
	+ for (;;) {
	+ key.k_chars[0] = c = getkey(TRUE);
	+ key.k_count = 1;
	+ if (c == '-')
	+ return (negative_argument(f, nn));
	+ if (c >= '0' && c <= '9')
	+ return (digit_argument(f, nn));
	+ curmap = curbp->b_modes[curbp->b_nmodes]->p_map;
	+ while ((funct = doscan(curmap, c, &curmap)) == NULL) {
	+ key.k_chars[key.k_count++] = c = getkey(TRUE);
	+ }
	+ if (funct != universal_argument) {
	+ if (macrodef && macrocount < MAXMACRO - 1) {
	+ if (f & FFARG)
	+ macrocount--;
	+ macro[macrocount++].m_count = nn;
	+ macro[macrocount++].m_funct = funct;
	+ }
	+ return (mgwrap(funct, FFUNIV, nn));
	+ }
	+ nn <<= 2;
	+ }
	+}
	+
	+/* ARGSUSED */
	+int
	+digit_argument(int f, int n)
	+{
	+ KEYMAP *curmap;
	+ PF funct;
	+ int nn, c;
	+
	+ nn = key.k_chars[key.k_count - 1] - '0';
	+ for (;;) {
	+ c = getkey(TRUE);
	+ if (c < '0' \|\| c > '9')
	+ break;
	+ nn *= 10;
	+ nn += c - '0';
	+ }
	+ key.k_chars[0] = c;
	+ key.k_count = 1;
	+ curmap = curbp->b_modes[curbp->b_nmodes]->p_map;
	+ while ((funct = doscan(curmap, c, &curmap)) == NULL) {
	+ key.k_chars[key.k_count++] = c = getkey(TRUE);
	+ }
	+ if (macrodef && macrocount < MAXMACRO - 1) {
	+ if (f & FFARG)
	+ macrocount--;
	+ else
	+ macro[macrocount - 1].m_funct = universal_argument;
	+ macro[macrocount++].m_count = nn;
	+ macro[macrocount++].m_funct = funct;
	+ }
	+ return (mgwrap(funct, FFOTHARG, nn));
	+}
	+
	+int
	+negative_argument(int f, int n)
	+{
	+ KEYMAP *curmap;
	+ PF funct;
	+ int c;
	+ int nn = 0;
	+
	+ for (;;) {
	+ c = getkey(TRUE);
	+ if (c < '0' \|\| c > '9')
	+ break;
	+ nn *= 10;
	+ nn += c - '0';
	+ }
	+ if (nn)
	+ nn = -nn;
	+ else
	+ nn = -n;
	+ key.k_chars[0] = c;
	+ key.k_count = 1;
	+ curmap = curbp->b_modes[curbp->b_nmodes]->p_map;
	+ while ((funct = doscan(curmap, c, &curmap)) == NULL) {
	+ key.k_chars[key.k_count++] = c = getkey(TRUE);
	+ }
	+ if (macrodef && macrocount < MAXMACRO - 1) {
	+ if (f & FFARG)
	+ macrocount--;
	+ else
	+ macro[macrocount - 1].m_funct = universal_argument;
	+ macro[macrocount++].m_count = nn;
	+ macro[macrocount++].m_funct = funct;
	+ }
	+ return (mgwrap(funct, FFNEGARG, nn));
	+}
	+
	+/*
	+ * Insert a character. While defining a macro, create a "LINE" containing
	+ * all inserted characters.
	+ */
	+int
	+selfinsert(int f, int n)
	+{
	+ struct line *lp;
	+ int c;
	+ int count;
	+
	+ if (n < 0)
	+ return (FALSE);
	+ if (n == 0)
	+ return (TRUE);
	+ c = key.k_chars[key.k_count - 1];
	+
	+ if (macrodef && macrocount < MAXMACRO) {
	+ if (f & FFARG)
	+ macrocount -= 2;
	+
	+ /* last command was insert -- tack on the end */
	+ if (lastflag & CFINS) {
	+ macrocount--;
	+ /* Ensure the line can handle the new characters */
	+ if (maclcur->l_size < maclcur->l_used + n) {
	+ if (lrealloc(maclcur, maclcur->l_used + n) ==
	+ FALSE)
	+ return (FALSE);
	+ }
	+ maclcur->l_used += n;
	+ /* Copy in the new data */
	+ for (count = maclcur->l_used - n;
	+ count < maclcur->l_used; count++)
	+ maclcur->l_text[count] = c;
	+ } else {
	+ macro[macrocount - 1].m_funct = insert;
	+ if ((lp = lalloc(n)) == NULL)
	+ return (FALSE);
	+ lp->l_bp = maclcur;
	+ lp->l_fp = maclcur->l_fp;
	+ maclcur->l_fp = lp;
	+ maclcur = lp;
	+ for (count = 0; count < n; count++)
	+ lp->l_text[count] = c;
	+ }
	+ thisflag \|= CFINS;
	+ }
	+ if (c == *curbp->b_nlchr) {
	+ do {
	+ count = lnewline();
	+ } while (--n && count == TRUE);
	+ return (count);
	+ }
	+
	+ /* overwrite mode */
	+ if (curbp->b_flag & BFOVERWRITE) {
	+ lchange(WFEDIT);
	+ while (curwp->w_doto < llength(curwp->w_dotp) && n--)
	+ lputc(curwp->w_dotp, curwp->w_doto++, c);
	+ if (n <= 0)
	+ return (TRUE);
	+ }
	+ return (linsert(n, c));
	+}
	+
	+/*
	+ * selfinsert() can't be called directly from a startup file or by
	+ * 'eval-current-buffer' since it is by design, meant to be called interactively
	+ * as characters are typed in a buffer. ask_selfinsert() allows selfinsert() to
	+ * be used by excline(). Having ask_selfinsert() helps with regression testing.
	+ * No manual page entry since use case is a bit obscure. See 'insert' command.
	+ */
	+int
	+ask_selfinsert(int f, int n)
	+{
	+ char *c, cbuf[2];
	+
	+ if ((c = eread("Insert a character: ", cbuf, sizeof(cbuf),
	+ EFNEW)) == NULL \|\| (c[0] == '\0'))
	+ return (ABORT);
	+
	+ key.k_chars[0] = *c;
	+ key.k_chars[1] = '\0';
	+ key.k_count = 1;
	+
	+ return (selfinsert(FFRAND, 1));
	+}
	+
	+/*
	+ * This could be implemented as a keymap with everything defined as self-insert.
	+ */
	+int
	+quote(int f, int n)
	+{
	+ int c;
	+
	+ key.k_count = 1;
	+ if ((key.k_chars[0] = getkey(TRUE)) >= '0' && key.k_chars[0] <= '7') {
	+ key.k_chars[0] -= '0';
	+ if ((c = getkey(TRUE)) >= '0' && c <= '7') {
	+ key.k_chars[0] <<= 3;
	+ key.k_chars[0] += c - '0';
	+ if ((c = getkey(TRUE)) >= '0' && c <= '7') {
	+ key.k_chars[0] <<= 3;
	+ key.k_chars[0] += c - '0';
	+ } else
	+ ungetkey(c);
	+ } else
	+ ungetkey(c);
	+ }
	+ return (selfinsert(f, n));
	+}
	+
	+/*
	+ * Wraper function to count invocation repeats.
	+ * We ignore any function whose sole purpose is to get us
	+ * to the intended function.
	+ */
	+static int
	+mgwrap(PF funct, int f, int n)
	+{
	+ static PF ofp;
	+
	+ if (funct != rescan &&
	+ funct != negative_argument &&
	+ funct != digit_argument &&
	+ funct != universal_argument) {
	+ if (funct == ofp)
	+ rptcount++;
	+ else
	+ rptcount = 0;
	+ ofp = funct;
	+ }
	+
	+ return ((*funct)(f, n));
	+}
	Index: contrib/mg/key.h
	===================================================================
	--- /dev/null
	+++ contrib/mg/key.h
	@@ -0,0 +1,14 @@
	+/* $OpenBSD: key.h,v 1.6 2019/06/22 15:38:15 lum Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/* key.h: Insert file for mg 2 functions that need to reference key pressed */
	+
	+#define MAXKEY 8 /* maximum number of prefix chars */
	+
	+struct key { /* the character sequence in a key */
	+ int k_count; /* number of chars */
	+ KCHAR k_chars[MAXKEY]; /* chars */
	+};
	+
	+extern struct key key;
	Index: contrib/mg/keymap.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/keymap.c
	@@ -0,0 +1,577 @@
	+/* $OpenBSD: keymap.c,v 1.59 2021/04/20 10:02:50 lum Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * Keyboard maps. This is character set dependent. The terminal specific
	+ * parts of building the keymap has been moved to a better place.
	+ */
	+
	+#include <sys/queue.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+
	+#include "def.h"
	+#include "kbd.h"
	+
	+/*
	+ * initial keymap declarations, deepest first
	+ */
	+
	+static PF cHcG[] = {
	+ ctrlg, /* ^G */
	+ help_help /* ^H */
	+};
	+
	+static PF cHa[] = {
	+ apropos_command, /* a */
	+ wallchart, /* b */
	+ desckey /* c */
	+};
	+
	+struct KEYMAPE (2) helpmap = {
	+ 2,
	+ 2,
	+ rescan,
	+ {
	+ {
	+ CCHR('G'), CCHR('H'), cHcG, NULL
	+ },
	+ {
	+ 'a', 'c', cHa, NULL
	+ }
	+ }
	+};
	+
	+static PF cCsc[] = {
	+ cscallerfuncs, /* c */
	+ csdefinition, /* d */
	+ csegrep, /* e */
	+ csfindfile, /* f */
	+ rescan, /* g */
	+ rescan, /* h */
	+ csfindinc, /* i */
	+ rescan, /* j */
	+ rescan, /* k */
	+ rescan, /* l */
	+ rescan, /* m */
	+ csnextmatch, /* n */
	+ rescan, /* o */
	+ csprevmatch, /* p */
	+ rescan, /* q */
	+ rescan, /* r */
	+ cssymbol, /* s */
	+ csfindtext /* t */
	+};
	+
	+static struct KEYMAPE (1) cCsmap = {
	+ 1,
	+ 1,
	+ rescan,
	+ {
	+ {
	+ 'c', 't', cCsc, NULL
	+ }
	+ }
	+};
	+
	+static PF cCs[] = {
	+ NULL /* s */
	+};
	+
	+struct KEYMAPE (2) ccmap = {
	+ 2,
	+ 2,
	+ rescan,
	+ {
	+ {
	+ CCHR('@'), CCHR('@'), (PF[]){ rescan }, NULL
	+ },
	+ {
	+ 's', 's', cCs, (KEYMAP *) & cCsmap
	+ }
	+ }
	+};
	+
	+static PF cX4cF[] = {
	+ poptofile, /* ^f */
	+ ctrlg /* ^g */
	+};
	+static PF cX4b[] = {
	+ poptobuffer, /* b */
	+ rescan, /* c */
	+ rescan, /* d */
	+ rescan, /* e */
	+ poptofile /* f */
	+};
	+static struct KEYMAPE (2) cX4map = {
	+ 2,
	+ 2,
	+ rescan,
	+ {
	+ {
	+ CCHR('F'), CCHR('G'), cX4cF, NULL
	+ },
	+ {
	+ 'b', 'f', cX4b, NULL
	+ }
	+ }
	+};
	+
	+static PF cXcB[] = {
	+ listbuffers, /* ^B */
	+ quit, /* ^C */
	+ rescan, /* ^D */
	+ rescan, /* ^E */
	+ filevisit, /* ^F */
	+ ctrlg /* ^G */
	+};
	+
	+static PF cXcJ[] = {
	+ dired_jump, /* ^J */
	+ rescan, /* ^K */
	+ lowerregion, /* ^L */
	+ rescan, /* ^M */
	+ rescan, /* ^N */
	+ deblank, /* ^O */
	+ rescan, /* ^P */
	+ togglereadonly, /* ^Q */
	+ filevisitro, /* ^R */
	+ filesave, /* ^S */
	+ rescan, /* ^T */
	+ upperregion, /* ^U */
	+ filevisitalt, /* ^V */
	+ filewrite, /* ^W */
	+ swapmark /* ^X */
	+};
	+
	+static PF cXlp[] = {
	+ definemacro, /* ( */
	+ finishmacro /* ) */
	+};
	+
	+static PF cX0[] = {
	+ delwind, /* 0 */
	+ onlywind, /* 1 */
	+ splitwind, /* 2 */
	+ rescan, /* 3 */
	+ NULL /* 4 */
	+};
	+
	+static PF cXeq[] = {
	+ showcpos /* = */
	+};
	+
	+static PF cXcar[] = {
	+ enlargewind, /* ^ */
	+ rescan, /* _ */
	+ next_error, /* ` */
	+ rescan, /* a */
	+ usebuffer, /* b */
	+ rescan, /* c */
	+ rescan, /* d */
	+ executemacro, /* e */
	+ setfillcol, /* f */
	+ gotoline, /* g */
	+ markbuffer, /* h */
	+ fileinsert, /* i */
	+ rescan, /* j */
	+ killbuffer_cmd, /* k */
	+ rescan, /* l */
	+ rescan, /* m */
	+ nextwind, /* n */
	+ nextwind, /* o */
	+ prevwind, /* p */
	+ rescan, /* q */
	+ rescan, /* r */
	+ savebuffers, /* s */
	+ rescan, /* t */
	+ undo /* u */
	+};
	+
	+struct KEYMAPE (6) cXmap = {
	+ 6,
	+ 6,
	+ rescan,
	+ {
	+ {
	+ CCHR('B'), CCHR('G'), cXcB, NULL
	+ },
	+ {
	+ CCHR('J'), CCHR('X'), cXcJ, NULL
	+ },
	+ {
	+ '(', ')', cXlp, NULL
	+ },
	+ {
	+ '0', '4', cX0, (KEYMAP *) & cX4map
	+ },
	+ {
	+ '=', '=', cXeq, NULL
	+ },
	+ {
	+ '^', 'u', cXcar, NULL
	+ }
	+ }
	+};
	+
	+static PF metacG[] = {
	+ ctrlg /* ^G */
	+};
	+
	+static PF metacV[] = {
	+ pagenext /* ^V */
	+};
	+
	+static PF metaspex[] = {
	+ justone, /* space */
	+ shellcommand /* ! */
	+};
	+
	+static PF metapct[] = {
	+ queryrepl /* % */
	+};
	+
	+static PF metami[] = {
	+ poptag, /* * */
	+ rescan, /* + */
	+ rescan, /* , */
	+ negative_argument, /* - */
	+ findtag, /* . */
	+ rescan, /* / */
	+ digit_argument, /* 0 */
	+ digit_argument, /* 1 */
	+ digit_argument, /* 2 */
	+ digit_argument, /* 3 */
	+ digit_argument, /* 4 */
	+ digit_argument, /* 5 */
	+ digit_argument, /* 6 */
	+ digit_argument, /* 7 */
	+ digit_argument, /* 8 */
	+ digit_argument, /* 9 */
	+ rescan, /* : */
	+ rescan, /* ; */
	+ gotobob, /* < */
	+ rescan, /* = */
	+ gotoeob /* > */
	+};
	+
	+static PF metasqf[] = {
	+ NULL, /* [ */
	+ delwhite, /* \ */
	+ rescan, /* ] */
	+ joinline, /* ^ */
	+ rescan, /* _ */
	+ rescan, /* ` */
	+ rescan, /* a */
	+ backword, /* b */
	+ capword, /* c */
	+ delfword, /* d */
	+ rescan, /* e */
	+ forwword, /* f */
	+ rescan, /* g */
	+ markpara /* h */
	+};
	+
	+static PF metal[] = {
	+ lowerword, /* l */
	+ backtoindent, /* m */
	+ rescan, /* n */
	+ rescan, /* o */
	+ rescan, /* p */
	+ fillpara, /* q */
	+ backsearch, /* r */
	+ forwsearch, /* s */
	+ transposeword, /* t */
	+ upperword, /* u */
	+ backpage, /* v */
	+ copyregion, /* w */
	+ extend, /* x */
	+ rescan, /* y */
	+ rescan, /* z */
	+ gotobop, /* { */
	+ piperegion, /* \| */
	+ gotoeop /* } */
	+};
	+
	+static PF metasqlZ[] = {
	+ rescan /* Z */
	+};
	+
	+static PF metatilde[] = {
	+ notmodified, /* ~ */
	+ delbword /* DEL */
	+};
	+
	+struct KEYMAPE (1) metasqlmap = {
	+ 1,
	+ 1,
	+ rescan,
	+ {
	+ {
	+ 'Z', 'Z', metasqlZ, NULL
	+ }
	+ }
	+};
	+
	+struct KEYMAPE (8) metamap = {
	+ 8,
	+ 8,
	+ rescan,
	+ {
	+ {
	+ CCHR('G'), CCHR('G'), metacG, NULL
	+ },
	+ {
	+ CCHR('V'), CCHR('V'), metacV, NULL
	+ },
	+ {
	+ ' ', '!', metaspex, NULL
	+ },
	+ {
	+ '%', '%', metapct, NULL
	+ },
	+ {
	+ '*', '>', metami, NULL
	+ },
	+ {
	+ '[', 'h', metasqf, (KEYMAP *) &metasqlmap
	+ },
	+ {
	+ 'l', '}', metal, NULL
	+ },
	+ {
	+ '~', CCHR('?'), metatilde, NULL
	+ }
	+ }
	+};
	+
	+static PF fund_at[] = {
	+ setmark, /* ^@ */
	+ gotobol, /* ^A */
	+ backchar, /* ^B */
	+ NULL, /* ^C */
	+ forwdel, /* ^D */
	+ gotoeol, /* ^E */
	+ forwchar, /* ^F */
	+ ctrlg, /* ^G */
	+};
	+
	+static PF fund_h[] = {
	+ NULL, /* ^H */
	+};
	+
	+
	+/* ^I is selfinsert */
	+static PF fund_CJ[] = {
	+ lfindent, /* ^J */
	+ killline, /* ^K */
	+ reposition, /* ^L */
	+ enewline, /* ^M */
	+ forwline, /* ^N */
	+ openline, /* ^O */
	+ backline, /* ^P */
	+ quote, /* ^Q */
	+ backisearch, /* ^R */
	+ forwisearch, /* ^S */
	+ twiddle, /* ^T */
	+ universal_argument, /* ^U */
	+ forwpage, /* ^V */
	+ killregion, /* ^W */
	+ NULL, /* ^X */
	+ yank, /* ^Y */
	+ spawncli /* ^Z */
	+};
	+
	+static PF fund_esc[] = {
	+ NULL, /* esc */
	+ rescan, /* ^\ selfinsert is default on fundamental */
	+ rescan, /* ^] */
	+ rescan, /* ^^ */
	+ undo /* ^_ */
	+};
	+
	+static PF fund_del[] = {
	+ backdel /* DEL */
	+};
	+
	+static PF fund_cb[] = {
	+ showmatch /* ) ] } */
	+};
	+
	+static struct KEYMAPE (8) fundmap = {
	+ 8,
	+ 8,
	+ selfinsert,
	+ {
	+ {
	+ CCHR('@'), CCHR('G'), fund_at, (KEYMAP *) & ccmap
	+ },
	+ {
	+ CCHR('H'), CCHR('H'), fund_h, (KEYMAP *) & helpmap
	+ },
	+ {
	+ CCHR('J'), CCHR('Z'), fund_CJ, (KEYMAP *) & cXmap
	+ },
	+ {
	+ CCHR('['), CCHR('_'), fund_esc, (KEYMAP *) & metamap
	+ },
	+ {
	+ ')', ')', fund_cb, NULL
	+ },
	+ {
	+ ']', ']', fund_cb, NULL
	+ },
	+ {
	+ '}', '}', fund_cb, NULL
	+ },
	+ {
	+ CCHR('?'), CCHR('?'), fund_del, NULL
	+ },
	+ }
	+};
	+
	+static PF fill_sp[] = {
	+ fillword /* ' ' */
	+};
	+
	+static struct KEYMAPE (1) fillmap = {
	+ 1,
	+ 1,
	+ rescan,
	+ {
	+ { ' ', ' ', fill_sp, NULL }
	+ }
	+};
	+
	+static PF indent_lf[] = {
	+ enewline, /* ^J */
	+ rescan, /* ^K */
	+ rescan, /* ^L */
	+ lfindent /* ^M */
	+};
	+
	+static struct KEYMAPE (1) indntmap = {
	+ 1,
	+ 1,
	+ rescan,
	+ {
	+ {
	+ CCHR('J'), CCHR('M'), indent_lf, NULL
	+ }
	+ }
	+};
	+
	+#ifdef NOTAB
	+static PF notab_tab[] = {
	+ space_to_tabstop /* ^I */
	+};
	+
	+static struct KEYMAPE (1) notabmap = {
	+ 1,
	+ 1,
	+ rescan,
	+ {
	+ {
	+ CCHR('I'), CCHR('I'), notab_tab, NULL
	+ }
	+ }
	+};
	+#endif /* NOTAB */
	+
	+static struct KEYMAPE (1) overwmap = {
	+ 0,
	+ 1, /* 1 to avoid 0 sized array */
	+ rescan,
	+ {
	+ /* unused dummy entry for VMS C */
	+ {
	+ (KCHAR)0, (KCHAR)0, NULL, NULL
	+ }
	+ }
	+};
	+
	+
	+/*
	+ * The basic (root) keyboard map
	+ */
	+struct maps_s fundamental_mode = { (KEYMAP *)&fundmap, "fundamental" };
	+
	+/*
	+ * give names to the maps, for use by help etc. If the map is to be bindable,
	+ * it must also be listed in the function name table below with the same
	+ * name. Maps created dynamically currently don't get added here, thus are
	+ * unnamed. Modes are just named keymaps with functions to add/subtract them
	+ * from a buffer's list of modes. If you change a mode name, change it in
	+ * modes.c also.
	+ */
	+
	+static struct maps_s map_table[] = {
	+ {(KEYMAP *) &fillmap, "fill",},
	+ {(KEYMAP *) &indntmap, "indent",},
	+#ifdef NOTAB
	+ {(KEYMAP *) &notabmap, "notab",},
	+#endif /* NOTAB */
	+ {(KEYMAP *) &overwmap, "overwrite",},
	+ {(KEYMAP *) &metamap, "esc prefix",},
	+ {(KEYMAP *) &cXmap, "c-x prefix",},
	+ {(KEYMAP *) &cX4map, "c-x 4 prefix",},
	+ {(KEYMAP *) &helpmap, "help",},
	+ {NULL, NULL}
	+};
	+
	+struct maps_s *maps;
	+
	+void
	+maps_init(void)
	+{
	+ int i;
	+ struct maps_s *mp;
	+
	+ maps = &fundamental_mode;
	+ for (i = 0; map_table[i].p_name != NULL; i++) {
	+ mp = &map_table[i];
	+ mp->p_next = maps;
	+ maps = mp;
	+ }
	+}
	+
	+/*
	+ * Insert a new (named) keymap at the head of the keymap list.
	+ */
	+int
	+maps_add(KEYMAP map, const char name)
	+{
	+ struct maps_s *mp;
	+
	+ if ((mp = malloc(sizeof(*mp))) == NULL)
	+ return (FALSE);
	+
	+ mp->p_name = name;
	+ mp->p_map = map;
	+ mp->p_next = maps;
	+ maps = mp;
	+
	+ return (TRUE);
	+}
	+
	+struct maps_s *
	+name_mode(const char *name)
	+{
	+ struct maps_s *mp;
	+
	+ for (mp = maps; mp != NULL; mp = mp->p_next)
	+ if (strcmp(mp->p_name, name) == 0)
	+ return (mp);
	+ return (NULL);
	+}
	+
	+KEYMAP *
	+name_map(const char *name)
	+{
	+ struct maps_s *mp;
	+
	+ return ((mp = name_mode(name)) == NULL ? NULL : mp->p_map);
	+}
	Index: contrib/mg/line.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/line.c
	@@ -0,0 +1,624 @@
	+/* $OpenBSD: line.c,v 1.63 2021/03/01 10:51:14 lum Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * Text line handling.
	+ *
	+ * The functions in this file are a general set of line management
	+ * utilities. They are the only routines that touch the text. They
	+ * also touch the buffer and window structures to make sure that the
	+ * necessary updating gets done.
	+ *
	+ * Note that this code only updates the dot and mark values in the window
	+ * list. Since all the code acts on the current window, the buffer that
	+ * we are editing must be displayed, which means that "b_nwnd" is non-zero,
	+ * which means that the dot and mark values in the buffer headers are
	+ * nonsense.
	+ */
	+
	+#include <sys/queue.h>
	+#include <ctype.h>
	+#include <limits.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+
	+#include "def.h"
	+
	+int casereplace = TRUE;
	+
	+/*
	+ * Preserve the case of the replaced string.
	+ */
	+int
	+setcasereplace(int f, int n)
	+{
	+ if (f & FFARG)
	+ casereplace = n > 0;
	+ else
	+ casereplace = !casereplace;
	+ ewprintf("Case-replace is %sabled", casereplace ? "en" : "dis");
	+ return (TRUE);
	+}
	+
	+/*
	+ * Allocate a new line of size `used'. lrealloc() can be called if the line
	+ * ever needs to grow beyond that.
	+ */
	+struct line *
	+lalloc(int used)
	+{
	+ struct line *lp;
	+
	+ if ((lp = malloc(sizeof(*lp))) == NULL)
	+ return (NULL);
	+ lp->l_text = NULL;
	+ lp->l_size = 0;
	+ lp->l_used = used; /* XXX */
	+ if (lrealloc(lp, used) == FALSE) {
	+ free(lp);
	+ return (NULL);
	+ }
	+ return (lp);
	+}
	+
	+int
	+lrealloc(struct line *lp, int newsize)
	+{
	+ char *tmp;
	+
	+ if (lp->l_size < newsize) {
	+ if ((tmp = realloc(lp->l_text, newsize)) == NULL)
	+ return (FALSE);
	+ lp->l_text = tmp;
	+ lp->l_size = newsize;
	+ }
	+ return (TRUE);
	+}
	+
	+/*
	+ * Delete line "lp". Fix all of the links that might point to it (they are
	+ * moved to offset 0 of the next line. Unlink the line from whatever buffer
	+ * it might be in, and release the memory. The buffers are updated too; the
	+ * magic conditions described in the above comments don't hold here.
	+ */
	+void
	+lfree(struct line *lp)
	+{
	+ struct buffer *bp;
	+ struct mgwin *wp;
	+
	+ for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
	+ if (wp->w_linep == lp)
	+ wp->w_linep = lp->l_fp;
	+ if (wp->w_dotp == lp) {
	+ wp->w_dotp = lp->l_fp;
	+ wp->w_doto = 0;
	+ }
	+ if (wp->w_markp == lp) {
	+ wp->w_markp = lp->l_fp;
	+ wp->w_marko = 0;
	+ }
	+ }
	+ for (bp = bheadp; bp != NULL; bp = bp->b_bufp) {
	+ if (bp->b_nwnd == 0) {
	+ if (bp->b_dotp == lp) {
	+ bp->b_dotp = lp->l_fp;
	+ bp->b_doto = 0;
	+ }
	+ if (bp->b_markp == lp) {
	+ bp->b_markp = lp->l_fp;
	+ bp->b_marko = 0;
	+ }
	+ }
	+ }
	+ lp->l_bp->l_fp = lp->l_fp;
	+ lp->l_fp->l_bp = lp->l_bp;
	+ free(lp->l_text);
	+ free(lp);
	+}
	+
	+/*
	+ * This routine is called when a character changes in place in the current
	+ * buffer. It updates all of the required flags in the buffer and window
	+ * system. The flag used is passed as an argument; if the buffer is being
	+ * displayed in more than 1 window we change EDIT to HARD. Set MODE if the
	+ * mode line needs to be updated (the "*" has to be set).
	+ */
	+void
	+lchange(int flag)
	+{
	+ struct mgwin *wp;
	+
	+ /* update mode lines if this is the first change. */
	+ if ((curbp->b_flag & BFCHG) == 0) {
	+ flag \|= WFMODE;
	+ curbp->b_flag \|= BFCHG;
	+ }
	+ for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
	+ if (wp->w_bufp == curbp) {
	+ wp->w_rflag \|= flag;
	+ if (wp != curwp)
	+ wp->w_rflag \|= WFFULL;
	+ }
	+ }
	+}
	+
	+/*
	+ * Insert "n" copies of the character "c" at the current location of dot.
	+ * In the easy case all that happens is the text is stored in the line.
	+ * In the hard case, the line has to be reallocated. When the window list
	+ * is updated, take special care; I screwed it up once. You always update
	+ * dot in the current window. You update mark and a dot in another window
	+ * if it is greater than the place where you did the insert. Return TRUE
	+ * if all is well, and FALSE on errors.
	+ */
	+int
	+linsert(int n, int c)
	+{
	+ struct line *lp1;
	+ struct mgwin *wp;
	+ RSIZE i;
	+ int doto;
	+ int s;
	+
	+ if (!n)
	+ return (TRUE);
	+
	+ if ((s = checkdirty(curbp)) != TRUE)
	+ return (s);
	+
	+ if (curbp->b_flag & BFREADONLY) {
	+ dobeep();
	+ ewprintf("Buffer is read only");
	+ return (FALSE);
	+ }
	+
	+ lchange(WFEDIT);
	+
	+ /* current line */
	+ lp1 = curwp->w_dotp;
	+
	+ /* special case for the end */
	+ if (lp1 == curbp->b_headp) {
	+ struct line lp2, lp3;
	+
	+ /* now should only happen in empty buffer */
	+ if (curwp->w_doto != 0) {
	+ dobeep();
	+ ewprintf("bug: linsert");
	+ return (FALSE);
	+ }
	+ /* allocate a new line */
	+ if ((lp2 = lalloc(n)) == NULL)
	+ return (FALSE);
	+ /* previous line */
	+ lp3 = lp1->l_bp;
	+ /* link in */
	+ lp3->l_fp = lp2;
	+ lp2->l_fp = lp1;
	+ lp1->l_bp = lp2;
	+ lp2->l_bp = lp3;
	+ for (i = 0; i < n; ++i)
	+ lp2->l_text[i] = c;
	+ for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
	+ if (wp->w_linep == lp1)
	+ wp->w_linep = lp2;
	+ if (wp->w_dotp == lp1)
	+ wp->w_dotp = lp2;
	+ if (wp->w_markp == lp1)
	+ wp->w_markp = lp2;
	+ }
	+ undo_add_insert(lp2, 0, n);
	+ curwp->w_doto = n;
	+ return (TRUE);
	+ }
	+ /* save for later */
	+ doto = curwp->w_doto;
	+
	+ if ((lp1->l_used + n) > lp1->l_size) {
	+ if (lrealloc(lp1, lp1->l_used + n) == FALSE)
	+ return (FALSE);
	+ }
	+ lp1->l_used += n;
	+ if (lp1->l_used != n)
	+ memmove(&lp1->l_text[doto + n], &lp1->l_text[doto],
	+ lp1->l_used - n - doto);
	+
	+ /* Add the characters */
	+ for (i = 0; i < n; ++i)
	+ lp1->l_text[doto + i] = c;
	+ for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
	+ if (wp->w_dotp == lp1) {
	+ if (wp == curwp \|\| wp->w_doto > doto)
	+ wp->w_doto += n;
	+ }
	+ if (wp->w_markp == lp1) {
	+ if (wp->w_marko > doto)
	+ wp->w_marko += n;
	+ }
	+ }
	+ undo_add_insert(curwp->w_dotp, doto, n);
	+ return (TRUE);
	+}
	+
	+/*
	+ * Do the work of inserting a newline at the given line/offset.
	+ * If mark is on the current line, we may have to move the markline
	+ * to keep line numbers in sync.
	+ * lnewline_at assumes the current buffer is writable. Checking for
	+ * this fact should be done by the caller.
	+ */
	+int
	+lnewline_at(struct line *lp1, int doto)
	+{
	+ struct line *lp2;
	+ struct mgwin *wp;
	+ int nlen, tcurwpdotline;
	+
	+ lchange(WFFULL);
	+
	+ curwp->w_bufp->b_lines++;
	+ /* Check if mark is past dot (even on current line) */
	+ if (curwp->w_markline > curwp->w_dotline \|\|
	+ (curwp->w_dotline == curwp->w_markline &&
	+ curwp->w_marko >= doto))
	+ curwp->w_markline++;
	+
	+ tcurwpdotline = curwp->w_dotline;
	+
	+ /* If start of line, allocate a new line instead of copying */
	+ if (doto == 0) {
	+ /* new first part */
	+ if ((lp2 = lalloc(0)) == NULL)
	+ return (FALSE);
	+ lp2->l_bp = lp1->l_bp;
	+ lp1->l_bp->l_fp = lp2;
	+ lp2->l_fp = lp1;
	+ lp1->l_bp = lp2;
	+ for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
	+ if (wp->w_linep == lp1)
	+ wp->w_linep = lp2;
	+ if (wp->w_dotline >= tcurwpdotline &&
	+ wp->w_bufp == curwp->w_bufp)
	+ wp->w_dotline++;
	+ }
	+ undo_add_boundary(FFRAND, 1);
	+ undo_add_insert(lp2, 0, 1);
	+ undo_add_boundary(FFRAND, 1);
	+ return (TRUE);
	+ }
	+
	+ /* length of new part */
	+ nlen = llength(lp1) - doto;
	+
	+ /* new second half line */
	+ if ((lp2 = lalloc(nlen)) == NULL)
	+ return (FALSE);
	+ if (nlen != 0)
	+ bcopy(&lp1->l_text[doto], &lp2->l_text[0], nlen);
	+ lp1->l_used = doto;
	+ lp2->l_bp = lp1;
	+ lp2->l_fp = lp1->l_fp;
	+ lp1->l_fp = lp2;
	+ lp2->l_fp->l_bp = lp2;
	+ /* Windows */
	+ for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
	+ if (wp->w_dotp == lp1 && wp->w_doto >= doto) {
	+ wp->w_dotp = lp2;
	+ wp->w_doto -= doto;
	+ wp->w_dotline++;
	+ } else if (wp->w_dotline > tcurwpdotline &&
	+ wp->w_bufp == curwp->w_bufp)
	+ wp->w_dotline++;
	+ if (wp->w_markp == lp1 && wp->w_marko >= doto) {
	+ wp->w_markp = lp2;
	+ wp->w_marko -= doto;
	+ }
	+ }
	+ undo_add_boundary(FFRAND, 1);
	+ undo_add_insert(lp1, llength(lp1), 1);
	+ undo_add_boundary(FFRAND, 1);
	+ return (TRUE);
	+}
	+
	+/*
	+ * Insert a newline into the buffer at the current location of dot in the
	+ * current window.
	+ */
	+int
	+lnewline(void)
	+{
	+ int s;
	+
	+ if ((s = checkdirty(curbp)) != TRUE)
	+ return (s);
	+ if (curbp->b_flag & BFREADONLY) {
	+ dobeep();
	+ ewprintf("Buffer is read only");
	+ return (FALSE);
	+ }
	+ return (lnewline_at(curwp->w_dotp, curwp->w_doto));
	+}
	+
	+/*
	+ * This function deletes "n" bytes, starting at dot. (actually, n+1, as the
	+ * newline is included) It understands how to deal with end of lines, etc.
	+ * It returns TRUE if all of the characters were deleted, and FALSE if
	+ * they were not (because dot ran into the end of the buffer).
	+ * The "kflag" indicates either no insertion, or direction of insertion
	+ * into the kill buffer.
	+ */
	+int
	+ldelete(RSIZE n, int kflag)
	+{
	+ struct line *dotp;
	+ RSIZE chunk;
	+ struct mgwin *wp;
	+ int doto;
	+ char cp1, cp2;
	+ size_t len;
	+ char *sv = NULL;
	+ int end;
	+ int s;
	+ int rval = FALSE;
	+
	+ if ((s = checkdirty(curbp)) != TRUE)
	+ return (s);
	+ if (curbp->b_flag & BFREADONLY) {
	+ dobeep();
	+ ewprintf("Buffer is read only");
	+ goto out;
	+ }
	+ len = n;
	+ if ((sv = calloc(1, len + 1)) == NULL)
	+ goto out;
	+ end = 0;
	+
	+ undo_add_delete(curwp->w_dotp, curwp->w_doto, n, (kflag & KREG));
	+
	+ while (n != 0) {
	+ dotp = curwp->w_dotp;
	+ doto = curwp->w_doto;
	+ /* Hit the end of the buffer */
	+ if (dotp == curbp->b_headp)
	+ goto out;
	+ /* Size of the chunk */
	+ chunk = dotp->l_used - doto;
	+
	+ if (chunk > n)
	+ chunk = n;
	+ /* End of line, merge */
	+ if (chunk == 0) {
	+ if (dotp == blastlp(curbp))
	+ goto out;
	+ lchange(WFFULL);
	+ if (ldelnewline() == FALSE)
	+ goto out;
	+ end = strlcat(sv, curbp->b_nlchr, len + 1);
	+ --n;
	+ continue;
	+ }
	+ lchange(WFEDIT);
	+ /* Scrunch text */
	+ cp1 = &dotp->l_text[doto];
	+ memcpy(&sv[end], cp1, chunk);
	+ end += chunk;
	+ sv[end] = '\0';
	+ for (cp2 = cp1 + chunk; cp2 < &dotp->l_text[dotp->l_used];
	+ cp2++)
	+ cp1++ = cp2;
	+ dotp->l_used -= (int)chunk;
	+ for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
	+ if (wp->w_dotp == dotp && wp->w_doto >= doto) {
	+ wp->w_doto -= chunk;
	+ if (wp->w_doto < doto)
	+ wp->w_doto = doto;
	+ }
	+ if (wp->w_markp == dotp && wp->w_marko >= doto) {
	+ wp->w_marko -= chunk;
	+ if (wp->w_marko < doto)
	+ wp->w_marko = doto;
	+ }
	+ }
	+ n -= chunk;
	+ }
	+ if (kchunk(sv, (RSIZE)len, kflag) != TRUE)
	+ goto out;
	+ rval = TRUE;
	+out:
	+ free(sv);
	+ return (rval);
	+}
	+
	+/*
	+ * Delete a newline and join the current line with the next line. If the next
	+ * line is the magic header line always return TRUE; merging the last line
	+ * with the header line can be thought of as always being a successful
	+ * operation. Even if nothing is done, this makes the kill buffer work
	+ * "right". If the mark is past the dot (actually, markline > dotline),
	+ * decrease the markline accordingly to keep line numbers in sync.
	+ * Easy cases can be done by shuffling data around. Hard cases
	+ * require that lines be moved about in memory. Return FALSE on error and
	+ * TRUE if all looks ok. We do not update w_dotline here, as deletes are done
	+ * after moves.
	+ */
	+int
	+ldelnewline(void)
	+{
	+ struct line lp1, lp2, *lp3;
	+ struct mgwin *wp;
	+ int s;
	+
	+ if ((s = checkdirty(curbp)) != TRUE)
	+ return (s);
	+ if (curbp->b_flag & BFREADONLY) {
	+ dobeep();
	+ ewprintf("Buffer is read only");
	+ return (FALSE);
	+ }
	+
	+ lp1 = curwp->w_dotp;
	+ lp2 = lp1->l_fp;
	+ /* at the end of the buffer */
	+ if (lp2 == curbp->b_headp)
	+ return (TRUE);
	+ /* Keep line counts in sync */
	+ curwp->w_bufp->b_lines--;
	+ if (curwp->w_markline > curwp->w_dotline)
	+ curwp->w_markline--;
	+ if (lp2->l_used <= lp1->l_size - lp1->l_used) {
	+ bcopy(&lp2->l_text[0], &lp1->l_text[lp1->l_used], lp2->l_used);
	+ for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
	+ if (wp->w_linep == lp2)
	+ wp->w_linep = lp1;
	+ if (wp->w_dotp == lp2) {
	+ wp->w_dotp = lp1;
	+ wp->w_doto += lp1->l_used;
	+ }
	+ if (wp->w_markp == lp2) {
	+ wp->w_markp = lp1;
	+ wp->w_marko += lp1->l_used;
	+ }
	+ }
	+ lp1->l_used += lp2->l_used;
	+ lp1->l_fp = lp2->l_fp;
	+ lp2->l_fp->l_bp = lp1;
	+ free(lp2);
	+ return (TRUE);
	+ }
	+ if ((lp3 = lalloc(lp1->l_used + lp2->l_used)) == NULL)
	+ return (FALSE);
	+ bcopy(&lp1->l_text[0], &lp3->l_text[0], lp1->l_used);
	+ bcopy(&lp2->l_text[0], &lp3->l_text[lp1->l_used], lp2->l_used);
	+ lp1->l_bp->l_fp = lp3;
	+ lp3->l_fp = lp2->l_fp;
	+ lp2->l_fp->l_bp = lp3;
	+ lp3->l_bp = lp1->l_bp;
	+ for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
	+ if (wp->w_linep == lp1 \|\| wp->w_linep == lp2)
	+ wp->w_linep = lp3;
	+ if (wp->w_dotp == lp1)
	+ wp->w_dotp = lp3;
	+ else if (wp->w_dotp == lp2) {
	+ wp->w_dotp = lp3;
	+ wp->w_doto += lp1->l_used;
	+ }
	+ if (wp->w_markp == lp1)
	+ wp->w_markp = lp3;
	+ else if (wp->w_markp == lp2) {
	+ wp->w_markp = lp3;
	+ wp->w_marko += lp1->l_used;
	+ }
	+ }
	+ free(lp1);
	+ free(lp2);
	+ return (TRUE);
	+}
	+
	+/*
	+ * Replace plen characters before dot with argument string. Control-J
	+ * characters in st are interpreted as newlines. There is a casehack
	+ * disable flag (normally it likes to match case of replacement to what
	+ * was there).
	+ */
	+int
	+lreplace(RSIZE plen, char *st)
	+{
	+ RSIZE rlen; /* replacement length */
	+ struct line *lp;
	+ RSIZE n;
	+ int s, doto, is_query_capitalised = 0, is_query_allcaps = 0;
	+ int is_replace_alllower = 0;
	+ char *repl = NULL;
	+
	+ if ((s = checkdirty(curbp)) != TRUE)
	+ return (s);
	+ if (curbp->b_flag & BFREADONLY) {
	+ dobeep();
	+ ewprintf("Buffer is read only");
	+ return (FALSE);
	+ }
	+
	+ if ((repl = strdup(st)) == NULL) {
	+ dobeep();
	+ ewprintf("out of memory");
	+ return (FALSE);
	+ }
	+ rlen = strlen(repl);
	+
	+ undo_boundary_enable(FFRAND, 0);
	+ (void)backchar(FFARG \| FFRAND, (int)plen);
	+
	+ if (casereplace != TRUE)
	+ goto done;
	+
	+ lp = curwp->w_dotp;
	+ if (ltext(lp) == NULL)
	+ goto done;
	+ doto = curwp->w_doto;
	+ n = plen;
	+
	+ is_query_capitalised = isupper((unsigned char)lgetc(lp, doto));
	+
	+ if (is_query_capitalised) {
	+ for (n = 0, is_query_allcaps = 1; n < plen && is_query_allcaps;
	+ n++) {
	+ is_query_allcaps = !isalpha((unsigned char)lgetc(lp,
	+ doto)) \|\| isupper((unsigned char)lgetc(lp, doto));
	+ doto++;
	+ if (doto == llength(lp)) {
	+ doto = 0;
	+ lp = lforw(lp);
	+ n++; /* \n is implicit in the buffer */
	+ }
	+ }
	+ }
	+
	+ for (n = 0, is_replace_alllower = 1; n < rlen && is_replace_alllower;
	+ n++)
	+ is_replace_alllower = !isupper((unsigned char)repl[n]);
	+
	+ if (is_replace_alllower) {
	+ if (is_query_allcaps) {
	+ for (n = 0; n < rlen; n++)
	+ repl[n] = toupper((unsigned char)repl[n]);
	+ } else if (is_query_capitalised) {
	+ repl[0] = toupper((unsigned char)repl[0]);
	+ }
	+ }
	+
	+ done:
	+ (void)ldelete(plen, KNONE);
	+ region_put_data(repl, rlen);
	+ lchange(WFFULL);
	+
	+ undo_boundary_enable(FFRAND, 1);
	+
	+ free(repl);
	+ return (TRUE);
	+}
	+
	+/*
	+ * Allocate and return the supplied line as a C string
	+ */
	+char *
	+linetostr(const struct line *ln)
	+{
	+ int len;
	+ char *line;
	+
	+ len = llength(ln);
	+ if (len == INT_MAX) /* (len + 1) overflow */
	+ return (NULL);
	+
	+ if ((line = malloc(len + 1)) == NULL)
	+ return (NULL);
	+
	+ (void)memcpy(line, ltext(ln), len);
	+ line[len] = '\0';
	+
	+ return (line);
	+}
	Index: contrib/mg/log.h
	===================================================================
	--- /dev/null
	+++ contrib/mg/log.h
	@@ -0,0 +1,33 @@
	+/* $OpenBSD: log.h,v 1.6 2021/03/02 13:06:50 lum Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * Specifically for mg logging functionality.
	+ *
	+ */
	+int mglog(PF, void *);
	+int mgloginit(void);
	+int mglog_execbuf( const char* const,
	+ const char* const,
	+ const char* const,
	+ const char* const,
	+ const int,
	+ const int,
	+ const char* const,
	+ const char* const,
	+ const char* const
	+ );
	+
	+int mglog_isvar( const char* const,
	+ const char* const,
	+ const int
	+ );
	+int mglog_misc( const char *, ...);
	+
	+extern const char *mglogpath_lines;
	+extern const char *mglogpath_undo;
	+extern const char *mglogpath_window;
	+extern const char *mglogpath_key;
	+extern const char *mglogpath_interpreter;
	+extern const char *mglogpath_misc;
	Index: contrib/mg/log.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/log.c
	@@ -0,0 +1,408 @@
	+/* $OpenBSD: log.c,v 1.12 2021/03/02 13:06:50 lum Exp $ */
	+
	+/*
	+ * This file is in the public domain.
	+ *
	+ * Author: Mark Lumsden <mark@showcomplex.com>
	+ *
	+ */
	+
	+/*
	+ * Record a history of an mg session for temporal debugging.
	+ * Sometimes pressing a key will set the scene for a bug only visible
	+ * dozens of keystrokes later. gdb has its limitations in this scenario.
	+ *
	+ * Note this file is not compiled into mg by default, you will need to
	+ * amend the 'Makefile' for that to happen. Because of this, the code
	+ * is subject to bit-rot. However, I know myself and others have
	+ * written similar functionally often enough, that recording the below
	+ * in a code repository could aid the developement efforts of mg, even
	+ * if it requires a bit of effort to get working. The current code is
	+ * written in the spirit of debugging (quickly and perhaps not ideal,
	+ * but it does what is required well enough). Should debugging become
	+ * more formalised within mg, then I would expect that to change.
	+ *
	+ * If you open a file with long lines to run through this debugging
	+ * code, you may run into problems with the 1st fprintf statement in
	+ * in the mglog_lines() function. mg sometimes segvs at a strlen call
	+ * in fprintf - possibly something to do with the format string?
	+ * "%s%p b^%p f.%p %d %d\t%c\|%s\n"
	+ * When I get time I will look into it. But since my debugging
	+ * generally revolves around a file like:
	+ *
	+ * abc
	+ * def
	+ * ghk
	+ *
	+ * I don't experience this bug. Just note it for future investigation.
	+ */
	+
	+#include <sys/queue.h>
	+#include <sys/stat.h>
	+#include <ctype.h>
	+#include <fcntl.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+#include <unistd.h>
	+#include <stdarg.h>
	+
	+#include "def.h"
	+#include "key.h"
	+#include "kbd.h"
	+#include "funmap.h"
	+#include "chrdef.h"
	+
	+#include "log.h"
	+
	+static char mglogfiles_create(FILE , char );
	+static int mglog_lines(PF);
	+static int mglog_undo(void);
	+static int mglog_window(void);
	+static int mglog_key(KEYMAP *map);
	+
	+const char *mglogdir;
	+const char *mglogpath_lines;
	+const char *mglogpath_undo;
	+const char *mglogpath_window;
	+const char *mglogpath_key;
	+const char *mglogpath_interpreter;
	+const char *mglogpath_misc;
	+int mgloglevel;
	+
	+FILE *fd_lines;
	+FILE *fd_undo;
	+FILE *fd_window;
	+FILE *fd_key;
	+FILE *fd_interpreter;
	+FILE *fd_misc;
	+
	+int
	+mglog(PF funct, void *map)
	+{
	+ if(!mglog_lines(funct))
	+ ewprintf("Problem logging lines");
	+ if(!mglog_undo())
	+ ewprintf("Problem logging undo");
	+ if(!mglog_window())
	+ ewprintf("Problem logging window");
	+ if(!mglog_key(map))
	+ ewprintf("Problem logging key");
	+
	+ return (TRUE);
	+}
	+
	+
	+static int
	+mglog_key(KEYMAP *map)
	+{
	+ PF *pfp;
	+
	+ if (ISWORD(*key.k_chars)) {
	+ fprintf(fd_key, "k_count:%d k_chars:%hd\tchr:%c\t", key.k_count,
	+ key.k_chars, CHARMASK(key.k_chars));
	+ } else {
	+ fprintf(fd_key, "k_count:%d k_chars:%hd\t\t", key.k_count,
	+ *key.k_chars);
	+ }
	+ fprintf(fd_key, "map:%p %d %d %p %hd %hd\n",
	+ map,
	+ map->map_num,
	+ map->map_max,
	+ map->map_default,
	+ map->map_element->k_base,
	+ map->map_element->k_num
	+ );
	+ for (pfp = map->map_element->k_funcp; *pfp != NULL; pfp++)
	+ fprintf(fd_key, "%s ", function_name(*pfp));
	+
	+ fprintf(fd_key, "\n\n");
	+ fflush(fd_key);
	+ return (TRUE);
	+}
	+
	+static int
	+mglog_window(void)
	+{
	+ struct mgwin *wp;
	+ int i;
	+
	+ for (wp = wheadp, i = 0; wp != NULL; wp = wp->w_wndp, ++i) {
	+ fprintf(fd_window,
	+ "%d wh%p wlst%p wbfp%p wlp%p wdtp%p wmkp%p wdto%d wmko%d" \
	+ " wtpr%d wntr%d wfrm%d wrfl%c wflg%c wwrl%p wdtl%d" \
	+ " wmkl%d\n",
	+ i,
	+ wp,
	+ &wp->w_list,
	+ wp->w_bufp,
	+ wp->w_linep,
	+ wp->w_dotp,
	+ wp->w_markp,
	+ wp->w_doto,
	+ wp->w_marko,
	+ wp->w_toprow,
	+ wp->w_ntrows,
	+ wp->w_frame,
	+ wp->w_rflag,
	+ wp->w_flag,
	+ wp->w_wrapline,
	+ wp->w_dotline,
	+ wp->w_markline
	+ );
	+ }
	+ fflush(fd_window);
	+ return (TRUE);
	+}
	+
	+static int
	+mglog_undo(void)
	+{
	+ struct undo_rec *rec;
	+ char buf[4096], tmp[1024];
	+ int num;
	+ char *jptr;
	+
	+ jptr = "^J"; /* :) */
	+ /*
	+ * From undo_dump()
	+ */
	+ num = 0;
	+ TAILQ_FOREACH(rec, &curbp->b_undo, next) {
	+ num++;
	+ fprintf(fd_undo, "%d:\t %s at %d ", num,
	+ (rec->type == DELETE) ? "DELETE":
	+ (rec->type == DELREG) ? "DELREGION":
	+ (rec->type == INSERT) ? "INSERT":
	+ (rec->type == BOUNDARY) ? "----" :
	+ (rec->type == MODIFIED) ? "MODIFIED": "UNKNOWN",
	+ rec->pos
	+ );
	+ if (rec->content) {
	+ (void)strlcat(buf, "\"", sizeof(buf));
	+ snprintf(tmp, sizeof(tmp), "%.*s",
	+ *rec->content == '\n' ? 2 : rec->region.r_size,
	+ *rec->content == '\n' ? jptr : rec->content);
	+ (void)strlcat(buf, tmp, sizeof(buf));
	+ (void)strlcat(buf, "\"", sizeof(buf));
	+ }
	+ snprintf(tmp, sizeof(tmp), " [%d]", rec->region.r_size);
	+ if (strlcat(buf, tmp, sizeof(buf)) >= sizeof(buf)) {
	+ dobeep();
	+ ewprintf("Undo record too large. Aborted.");
	+ return (FALSE);
	+ }
	+ fprintf(fd_undo, "%s\n", buf);
	+ tmp[0] = buf[0] = '\0';
	+ }
	+ fprintf(fd_undo, "\t [end-of-undo]\n\n");
	+ fflush(fd_undo);
	+
	+ return (TRUE);
	+}
	+
	+static int
	+mglog_lines(PF funct)
	+{
	+ struct line *lp;
	+ char curline, tmp, o;
	+ int i;
	+
	+ i = 0;
	+
	+ fprintf(fd_lines, "%s\n", function_name(funct));
	+ lp = bfirstlp(curbp);
	+
	+ for(;;) {
	+ i++;
	+ curline = " ";
	+ o = ' ';
	+ if (i == curwp->w_dotline) {
	+ curline = ">";
	+ if (lp->l_used > 0 && curwp->w_doto < lp->l_used)
	+ o = lp->l_text[curwp->w_doto];
	+ else
	+ o = '-';
	+ }
	+ if (lp->l_size == 0)
	+ tmp = " ";
	+ else
	+ tmp = lp->l_text;
	+
	+ /* segv on fprintf below with long lines */
	+ fprintf(fd_lines, "%s%p b^%p f.%p %d %d\t%c\|%s\n", curline,
	+ lp, lp->l_bp, lp->l_fp,
	+ lp->l_size, lp->l_used, o, tmp);
	+
	+ lp = lforw(lp);
	+ if (lp == curbp->b_headp) {
	+ fprintf(fd_lines, " %p b^%p f.%p [bhead]\n(EOB)\n",
	+ lp, lp->l_bp, lp->l_fp);
	+
	+ fprintf(fd_lines, "lines:raw:%d buf:%d wdot:%d\n\n",
	+ i, curbp->b_lines, curwp->w_dotline);
	+
	+ break;
	+ }
	+ }
	+ fflush(fd_lines);
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * See what the eval variable code is up to.
	+ */
	+int
	+mglog_isvar(
	+ const char* const argbuf,
	+ const char* const argp,
	+ const int sizof
	+)
	+{
	+
	+ fprintf(fd_interpreter, " argbuf:%s,argp:%s,sizof:%d<\n",
	+ argbuf,
	+ argp,
	+ sizof);
	+
	+ fflush(fd_interpreter);
	+ return (TRUE);
	+}
	+
	+/*
	+ * See what the eval line code is up to.
	+ */
	+int
	+mglog_execbuf(
	+ const char* const pre,
	+ const char* const excbuf,
	+ const char* const argbuf,
	+ const char* const argp,
	+ const int last,
	+ const int inlist,
	+ const char* const cmdp,
	+ const char* const p,
	+ const char* const contbuf
	+)
	+{
	+ fprintf(fd_interpreter, "%sexcbuf:%s,argbuf:%s,argp:%s,last:%d,inlist:%d,"\
	+ "cmdp:%s,p:%s,contbuf:%s<\n",
	+ pre,
	+ excbuf,
	+ argbuf,
	+ argp,
	+ last,
	+ inlist,
	+ cmdp,
	+ p,
	+ contbuf
	+ );
	+ fflush(fd_interpreter);
	+ return (TRUE);
	+}
	+
	+/*
	+ * Misc. logging for various subsystems
	+ */
	+int
	+mglog_misc(
	+ const char *fmt,
	+ ...
	+)
	+{
	+ va_list ap;
	+ int rc;
	+
	+ va_start(ap, fmt);
	+ rc = vfprintf(fd_misc, fmt, ap);
	+ va_end(ap);
	+ fflush(fd_misc);
	+
	+ if (rc < 0)
	+ return (FALSE);
	+
	+ return (TRUE);
	+}
	+
	+
	+
	+/*
	+ * Make sure logging to log files can happen.
	+ */
	+int
	+mgloginit(void)
	+{
	+ struct stat sb;
	+ mode_t dir_mode, f_mode, oumask;
	+ char mglogfile_lines, mglogfile_undo, *mglogfile_window;
	+ char mglogfile_key, mglogfile_interpreter, *mglogfile_misc;
	+
	+ mglogdir = "./log/";
	+ mglogfile_lines = "line.log";
	+ mglogfile_undo = "undo.log";
	+ mglogfile_window = "window.log";
	+ mglogfile_key = "key.log";
	+ mglogfile_interpreter = "interpreter.log";
	+ mglogfile_misc = "misc.log";
	+
	+ /*
	+ * Change mgloglevel for desired level of logging.
	+ * log.h has relevant level info.
	+ */
	+ mgloglevel = 1;
	+
	+ oumask = umask(0);
	+ f_mode = 0777& ~oumask;
	+ dir_mode = f_mode \| S_IWUSR \| S_IXUSR;
	+
	+ if(stat(mglogdir, &sb)) {
	+ if (mkdir(mglogdir, dir_mode) != 0)
	+ return (FALSE);
	+ if (chmod(mglogdir, f_mode) == -1)
	+ return (FALSE);
	+ }
	+ mglogpath_lines = mglogfiles_create(&fd_lines, mglogfile_lines);
	+ if (mglogpath_lines == NULL)
	+ return (FALSE);
	+ mglogpath_undo = mglogfiles_create(&fd_undo, mglogfile_undo);
	+ if (mglogpath_undo == NULL)
	+ return (FALSE);
	+ mglogpath_window = mglogfiles_create(&fd_window, mglogfile_window);
	+ if (mglogpath_window == NULL)
	+ return (FALSE);
	+ mglogpath_key = mglogfiles_create(&fd_key, mglogfile_key);
	+ if (mglogpath_key == NULL)
	+ return (FALSE);
	+ mglogpath_interpreter = mglogfiles_create(&fd_interpreter,
	+ mglogfile_interpreter);
	+ if (mglogpath_interpreter == NULL)
	+ return (FALSE);
	+ mglogpath_misc = mglogfiles_create(&fd_misc, mglogfile_misc);
	+ if (mglogpath_misc == NULL)
	+ return (FALSE);
	+
	+ return (TRUE);
	+}
	+
	+
	+static char *
	+mglogfiles_create(FILE ** fd, char *mglogfile)
	+{
	+ char tmp[NFILEN], *tmp2;
	+
	+ if (strlcpy(tmp, mglogdir, sizeof(tmp)) >
	+ sizeof(tmp))
	+ return (NULL);
	+ if (strlcat(tmp, mglogfile, sizeof(tmp)) >
	+ sizeof(tmp))
	+ return (NULL);
	+ if ((tmp2 = strndup(tmp, NFILEN)) == NULL)
	+ return (NULL);
	+
	+ if ((*fd = fopen(tmp2, "w")) == NULL)
	+ return (NULL);
	+
	+ return (tmp2);
	+}
	Index: contrib/mg/macro.h
	===================================================================
	--- /dev/null
	+++ contrib/mg/macro.h
	@@ -0,0 +1,21 @@
	+/* $OpenBSD: macro.h,v 1.7 2005/11/18 20:56:53 deraadt Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/* definitions for keyboard macros */
	+
	+#define MAXMACRO 256 /* maximum functs in a macro */
	+
	+extern int inmacro;
	+extern int macrodef;
	+extern int macrocount;
	+
	+union macrodef {
	+ PF m_funct;
	+ int m_count; /* for count-prefix */
	+};
	+
	+extern union macrodef macro[MAXMACRO];
	+
	+extern struct line *maclhead;
	+extern struct line *maclcur;
	Index: contrib/mg/macro.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/macro.c
	@@ -0,0 +1,112 @@
	+/* $OpenBSD: macro.c,v 1.16 2015/03/19 21:22:15 bcallah Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * Keyboard macros.
	+ */
	+
	+#include <sys/queue.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+
	+#include "def.h"
	+#include "key.h"
	+#include "macro.h"
	+
	+int inmacro = FALSE; /* Macro playback in progess */
	+int macrodef = FALSE; /* Macro recording in progress */
	+int macrocount = 0;
	+
	+struct line *maclhead = NULL;
	+struct line *maclcur;
	+
	+union macrodef macro[MAXMACRO];
	+
	+/* ARGSUSED */
	+int
	+definemacro(int f, int n)
	+{
	+ struct line lp1, lp2;
	+
	+ macrocount = 0;
	+
	+ if (macrodef) {
	+ ewprintf("already defining macro");
	+ return (macrodef = FALSE);
	+ }
	+
	+ /* free lines allocated for string arguments */
	+ if (maclhead != NULL) {
	+ for (lp1 = maclhead->l_fp; lp1 != maclhead; lp1 = lp2) {
	+ lp2 = lp1->l_fp;
	+ free(lp1);
	+ }
	+ free(lp1);
	+ }
	+
	+ if ((maclhead = lp1 = lalloc(0)) == NULL)
	+ return (FALSE);
	+
	+ ewprintf("Defining Keyboard Macro...");
	+ maclcur = lp1->l_fp = lp1->l_bp = lp1;
	+ return (macrodef = TRUE);
	+}
	+
	+/* ARGSUSED */
	+int
	+finishmacro(int f, int n)
	+{
	+ if (macrodef == TRUE) {
	+ macrodef = FALSE;
	+ ewprintf("End Keyboard Macro Definition");
	+ return (TRUE);
	+ }
	+ return (FALSE);
	+}
	+
	+/* ARGSUSED */
	+int
	+executemacro(int f, int n)
	+{
	+ int i, j, flag, num;
	+ PF funct;
	+
	+ if (macrodef \|\|
	+ (macrocount >= MAXMACRO && macro[MAXMACRO - 1].m_funct
	+ != finishmacro)) {
	+ dobeep();
	+ ewprintf("Macro too long. Aborting.");
	+ return (FALSE);
	+ }
	+
	+ if (macrocount == 0)
	+ return (TRUE);
	+
	+ inmacro = TRUE;
	+
	+ for (i = n; i > 0; i--) {
	+ maclcur = maclhead->l_fp;
	+ flag = 0;
	+ num = 1;
	+ for (j = 0; j < macrocount - 1; j++) {
	+ funct = macro[j].m_funct;
	+ if (funct == universal_argument) {
	+ flag = FFARG;
	+ num = macro[++j].m_count;
	+ continue;
	+ }
	+ if ((*funct)(flag, num) != TRUE) {
	+ inmacro = FALSE;
	+ return (FALSE);
	+ }
	+ lastflag = thisflag;
	+ thisflag = 0;
	+ flag = 0;
	+ num = 1;
	+ }
	+ }
	+ inmacro = FALSE;
	+ return (TRUE);
	+}
	Index: contrib/mg/main.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/main.c
	@@ -0,0 +1,343 @@
	+/* $OpenBSD: main.c,v 1.90 2021/05/03 12:18:43 lum Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * Mainline.
	+ */
	+
	+#include <sys/queue.h>
	+#include <err.h>
	+#include <limits.h>
	+#include <locale.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+#include <termios.h>
	+#include <unistd.h>
	+#if defined(__linux__) \|\| defined(__CYGWIN__)
	+#include <pty.h>
	+#elif defined(__OpenBSD__) \|\| defined(__NetBSD__) \|\| defined(__APPLE__)
	+#include <util.h>
	+#else
	+#include <libutil.h>
	+#endif
	+
	+#include "def.h"
	+#include "kbd.h"
	+#include "funmap.h"
	+#include "macro.h"
	+
	+#ifdef MGLOG
	+#include "log.h"
	+#endif
	+
	+int thisflag; /* flags, this command */
	+int lastflag; /* flags, last command */
	+int curgoal; /* goal column */
	+int startrow; /* row to start */
	+int doaudiblebell; /* audible bell toggle */
	+int dovisiblebell; /* visible bell toggle */
	+int dblspace; /* sentence end #spaces */
	+int allbro; /* all buffs read-only */
	+int batch; /* for regress tests */
	+struct buffer curbp; / current buffer */
	+struct buffer bheadp; / BUFFER list head */
	+struct mgwin curwp; / current window */
	+struct mgwin wheadp; / MGWIN listhead */
	+struct vhead varhead; /* Variable list head */
	+char pat[NPAT]; /* pattern */
	+
	+static void edinit(struct buffer *);
	+static void pty_init(void);
	+static __dead void usage(void);
	+
	+extern char *__progname;
	+extern void closetags(void);
	+
	+static __dead void
	+usage()
	+{
	+ fprintf(stderr, "usage: %s [-nR] [-b file] [-f mode] [-u file] "
	+ "[+number] [file ...]\n",
	+ __progname);
	+ exit(1);
	+}
	+
	+int
	+main(int argc, char **argv)
	+{
	+ char cp, conffile = NULL, *init_fcn_name = NULL;
	+ char *batchfile = NULL;
	+ PF init_fcn = NULL;
	+ int o, i, nfiles;
	+ int nobackups = 0;
	+ struct buffer *bp = NULL;
	+
	+#ifdef HAVE_PLEDGE
	+ if (pledge("stdio rpath wpath cpath fattr chown getpw tty proc exec",
	+ NULL) == -1)
	+ err(1, "pledge");
	+#endif
	+
	+ while ((o = getopt(argc, argv, "nRb:f:u:")) != -1)
	+ switch (o) {
	+ case 'b':
	+ batch = 1;
	+ batchfile = optarg;
	+ break;
	+ case 'R':
	+ allbro = 1;
	+ break;
	+ case 'n':
	+ nobackups = 1;
	+ break;
	+ case 'f':
	+ if (init_fcn_name != NULL)
	+ errx(1, "cannot specify more than one "
	+ "initial function");
	+ init_fcn_name = optarg;
	+ break;
	+ case 'u':
	+ conffile = optarg;
	+ break;
	+ default:
	+ usage();
	+ }
	+
	+ if (batch && (conffile != NULL)) {
	+ fprintf(stderr, "%s: -b and -u are mutually exclusive.\n",
	+ __progname);
	+ exit(1);
	+ }
	+ if (batch) {
	+ pty_init();
	+ conffile = batchfile;
	+ }
	+ if (conffile != NULL && access(conffile, R_OK) != 0) {
	+ fprintf(stderr, "%s: Problem with file: %s\n", __progname,
	+ conffile);
	+ exit(1);
	+ }
	+
	+ argc -= optind;
	+ argv += optind;
	+
	+ setlocale(LC_CTYPE, "");
	+
	+ maps_init(); /* Keymaps and modes. */
	+ funmap_init(); /* Functions. */
	+
	+#ifdef MGLOG
	+ if (!mgloginit())
	+ errx(1, "Unable to create logging environment.");
	+#endif
	+
	+ /*
	+ * This is where we initialize standalone extensions that should
	+ * be loaded dynamically sometime in the future.
	+ */
	+ {
	+ extern void grep_init(void);
	+ extern void cmode_init(void);
	+ extern void dired_init(void);
	+
	+ dired_init();
	+ grep_init();
	+ cmode_init();
	+ }
	+
	+ if (init_fcn_name &&
	+ (init_fcn = name_function(init_fcn_name)) == NULL)
	+ errx(1, "Unknown function `%s'", init_fcn_name);
	+
	+ vtinit(); /* Virtual terminal. */
	+ dirinit(); /* Get current directory. */
	+ edinit(bp); /* Buffers, windows. */
	+ ttykeymapinit(); /* Symbols, bindings. */
	+ bellinit(); /* Audible and visible bell. */
	+ dblspace = 1; /* two spaces for sentence end. */
	+
	+ /*
	+ * doing update() before reading files causes the error messages from
	+ * the file I/O show up on the screen. (and also an extra display of
	+ * the mode line if there are files specified on the command line.)
	+ */
	+ update(CMODE);
	+
	+ /* user startup file. */
	+ if ((cp = startupfile(NULL, conffile)) != NULL)
	+ (void)load(cp);
	+
	+ if (batch)
	+ return (0);
	+
	+ /*
	+ * Now ensure any default buffer modes from the startup file are
	+ * given to any files opened when parsing the startup file.
	+ * Note scratch will also be updated.
	+ */
	+ for (bp = bheadp; bp != NULL; bp = bp->b_bufp) {
	+ bp->b_flag = defb_flag;
	+ for (i = 0; i <= defb_nmodes; i++) {
	+ bp->b_modes[i] = defb_modes[i];
	+ }
	+ }
	+
	+ /* Force FFOTHARG=1 so that this mode is enabled, not simply toggled */
	+ if (init_fcn)
	+ init_fcn(FFOTHARG, 1);
	+
	+ if (nobackups)
	+ makebkfile(FFARG, 0);
	+
	+ for (nfiles = 0, i = 0; i < argc; i++) {
	+ if (argv[i][0] == '+' && strlen(argv[i]) >= 2) {
	+ long long lval;
	+ const char *errstr;
	+
	+ lval = strtonum(&argv[i][1], INT_MIN, INT_MAX, &errstr);
	+ if (argv[i][1] == '\0' \|\| errstr != NULL)
	+ goto notnum;
	+ startrow = lval;
	+ } else {
	+notnum:
	+ cp = adjustname(argv[i], FALSE);
	+ if (cp != NULL) {
	+ if (nfiles == 1)
	+ splitwind(0, 1);
	+
	+ if (fisdir(cp) == TRUE) {
	+ (void)do_dired(cp);
	+ continue;
	+ }
	+ if ((curbp = findbuffer(cp)) == NULL) {
	+ vttidy();
	+ errx(1, "Can't find current buffer!");
	+ }
	+ (void)showbuffer(curbp, curwp, 0);
	+ if (readin(cp) != TRUE)
	+ killbuffer(curbp);
	+ else {
	+ /* Ensure enabled, not just toggled */
	+ if (init_fcn_name)
	+ init_fcn(FFOTHARG, 1);
	+ nfiles++;
	+ }
	+ if (allbro)
	+ curbp->b_flag \|= BFREADONLY;
	+ }
	+ }
	+ }
	+
	+ if (nfiles > 2)
	+ listbuffers(0, 1);
	+
	+ /* fake last flags */
	+ thisflag = 0;
	+ for (;;) {
	+ if (epresf == KCLEAR)
	+ eerase();
	+ if (epresf == TRUE)
	+ epresf = KCLEAR;
	+ if (winch_flag) {
	+ do_redraw(0, 0, TRUE);
	+ winch_flag = 0;
	+ }
	+ update(CMODE);
	+ lastflag = thisflag;
	+ thisflag = 0;
	+
	+ switch (doin()) {
	+ case TRUE:
	+ break;
	+ case ABORT:
	+ ewprintf("Quit");
	+ /* FALLTHRU */
	+ case FALSE:
	+ default:
	+ macrodef = FALSE;
	+ }
	+ }
	+}
	+
	+/*
	+ * Initialize default buffer and window. Default buffer is called scratch.
	+ */
	+static void
	+edinit(struct buffer *bp)
	+{
	+ struct mgwin *wp;
	+
	+ bheadp = NULL;
	+ bp = bfind("scratch", TRUE); /* Text buffer. */
	+ if (bp == NULL)
	+ panic("edinit");
	+
	+ wp = new_window(bp);
	+ if (wp == NULL)
	+ panic("edinit: Out of memory");
	+
	+ curbp = bp; /* Current buffer. */
	+ wheadp = wp;
	+ curwp = wp;
	+ wp->w_wndp = NULL; /* Initialize window. */
	+ wp->w_linep = wp->w_dotp = bp->b_headp;
	+ wp->w_ntrows = nrow - 2; /* 2 = mode, echo. */
	+ wp->w_rflag = WFMODE \| WFFULL; /* Full. */
	+}
	+
	+/*
	+ * Create pty for batch mode.
	+ */
	+static void
	+pty_init(void)
	+{
	+ struct winsize ws;
	+ int master;
	+ int slave;
	+
	+ memset(&ws, 0, sizeof(ws));
	+ ws.ws_col = 80,
	+ ws.ws_row = 24;
	+
	+ openpty(&master, &slave, NULL, NULL, &ws);
	+ login_tty(slave);
	+
	+ return;
	+}
	+
	+/*
	+ * Quit command. If an argument, always quit. Otherwise confirm if a buffer
	+ * has been changed and not written out. Normally bound to "C-x C-c".
	+ */
	+/* ARGSUSED */
	+int
	+quit(int f, int n)
	+{
	+ int s;
	+
	+ if ((s = anycb(FALSE)) == ABORT)
	+ return (ABORT);
	+ if (s == FIOERR \|\| s == UERROR)
	+ return (FALSE);
	+ if (s == FALSE
	+ \|\| eyesno("Modified buffers exist; really exit") == TRUE) {
	+ vttidy();
	+ closetags();
	+ exit(0);
	+ }
	+ return (TRUE);
	+}
	+
	+/*
	+ * User abort. Should be called by any input routine that sees a C-g to abort
	+ * whatever C-g is aborting these days. Currently does nothing.
	+ */
	+/* ARGSUSED */
	+int
	+ctrlg(int f, int n)
	+{
	+ return (ABORT);
	+}
	Index: contrib/mg/match.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/match.c
	@@ -0,0 +1,190 @@
	+/* $OpenBSD: match.c,v 1.22 2021/03/01 10:51:14 lum Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * Limited parenthesis matching routines
	+ *
	+ * The hacks in this file implement automatic matching * of (), [], {}, and
	+ * other characters. It would be better to have a full-blown syntax table,
	+ * but there's enough overhead in the editor as it is.
	+ */
	+
	+#include <sys/queue.h>
	+#include <signal.h>
	+#include <stdio.h>
	+
	+#include "def.h"
	+#include "key.h"
	+
	+static int balance(void);
	+static void displaymatch(struct line *, int);
	+
	+/*
	+ * Balance table. When balance() encounters a character that is to be
	+ * matched, it first searches this table for a balancing left-side character.
	+ * If the character is not in the table, the character is balanced by itself.
	+ */
	+static struct balance {
	+ char left, right;
	+} bal[] = {
	+ { '(', ')' },
	+ { '[', ']' },
	+ { '{', '}' },
	+ { '<', '>' },
	+ { '\0', '\0' }
	+};
	+
	+/*
	+ * Hack to show matching paren. Self-insert character, then show matching
	+ * character, if any. Bound to "blink-and-insert". Used in the mg startup
	+ * file to amend the default cursor behaviour of a key press, e.g:
	+ * global-set-key "%" blink-and-insert
	+ */
	+int
	+showmatch(int f, int n)
	+{
	+ int i, s;
	+
	+ for (i = 0; i < n; i++) {
	+ if ((s = selfinsert(FFRAND, 1)) != TRUE)
	+ return (s);
	+ /* unbalanced -- warn user */
	+ if (balance() != TRUE)
	+ dobeep();
	+ }
	+ return (TRUE);
	+}
	+
	+/*
	+ * Search for and display a matching character.
	+ *
	+ * This routine does the real work of searching backward
	+ * for a balancing character. If such a balancing character
	+ * is found, it uses displaymatch() to display the match.
	+ */
	+static int
	+balance(void)
	+{
	+ struct line *clp;
	+ int cbo;
	+ int c, i, depth;
	+ int rbal, lbal;
	+
	+ rbal = key.k_chars[key.k_count - 1];
	+
	+ /* See if there is a matching character -- default to the same */
	+ lbal = rbal;
	+ for (i = 0; bal[i].right != '\0'; i++)
	+ if (bal[i].right == rbal) {
	+ lbal = bal[i].left;
	+ break;
	+ }
	+
	+ /*
	+ * Move behind the inserted character. We are always guaranteed
	+ * that there is at least one character on the line.
	+ */
	+ clp = curwp->w_dotp;
	+ cbo = curwp->w_doto - 1;
	+
	+ /* init nesting depth */
	+ depth = 0;
	+
	+ for (;;) {
	+ if (cbo == 0) {
	+ clp = lback(clp); /* beginning of line */
	+ if (clp == curbp->b_headp)
	+ return (FALSE);
	+ cbo = llength(clp) + 1;
	+ }
	+ if (--cbo == llength(clp))
	+ c = curbp->b_nlchr; / end of line */
	+ else
	+ c = lgetc(clp, cbo); /* somewhere in middle */
	+
	+ /*
	+ * Check for a matching character. If still in a nested
	+ * level, pop out of it and continue search. This check
	+ * is done before the nesting check so single-character
	+ * matches will work too.
	+ */
	+ if (c == lbal) {
	+ if (depth == 0) {
	+ displaymatch(clp, cbo);
	+ return (TRUE);
	+ } else
	+ depth--;
	+ }
	+ /* Check for another level of nesting. */
	+ if (c == rbal)
	+ depth++;
	+ }
	+ /* NOTREACHED */
	+}
	+
	+/*
	+ * Display matching character. Matching characters that are not in the
	+ * current window are displayed in the echo line. If in the current window,
	+ * move dot to the matching character, sit there a while, then move back.
	+ */
	+static void
	+displaymatch(struct line *clp, int cbo)
	+{
	+ struct line *tlp;
	+ int tbo;
	+ int cp;
	+ int bufo;
	+ int c;
	+ int inwindow;
	+ char buf[NLINE];
	+
	+ /*
	+ * Figure out if matching char is in current window by
	+ * searching from the top of the window to dot.
	+ */
	+ inwindow = FALSE;
	+ for (tlp = curwp->w_linep; tlp != lforw(curwp->w_dotp);
	+ tlp = lforw(tlp))
	+ if (tlp == clp)
	+ inwindow = TRUE;
	+
	+ if (inwindow == TRUE) {
	+ tlp = curwp->w_dotp; /* save current position */
	+ tbo = curwp->w_doto;
	+
	+ curwp->w_dotp = clp; /* move to new position */
	+ curwp->w_doto = cbo;
	+ curwp->w_rflag \|= WFMOVE;
	+
	+ update(CMODE); /* show match */
	+ ttwait(1000); /* wait for key or 1 second */
	+
	+ curwp->w_dotp = tlp; /* return to old position */
	+ curwp->w_doto = tbo;
	+ curwp->w_rflag \|= WFMOVE;
	+ update(CMODE);
	+ } else {
	+ /* match is not in this window, so display line in echo area */
	+ bufo = 0;
	+ for (cp = 0; cp < llength(clp); cp++) {
	+ c = lgetc(clp, cp);
	+ if (c != '\t'
	+#ifdef NOTAB
	+ \|\| (curbp->b_flag & BFNOTAB)
	+#endif
	+ )
	+ if (ISCTRL(c)) {
	+ buf[bufo++] = '^';
	+ buf[bufo++] = CCHR(c);
	+ } else
	+ buf[bufo++] = c;
	+ else
	+ do {
	+ buf[bufo++] = ' ';
	+ } while (bufo & 7);
	+ }
	+ buf[bufo++] = '\0';
	+ ewprintf("Matches %s", buf);
	+ }
	+}
	Index: contrib/mg/mg.1
	===================================================================
	--- /dev/null
	+++ contrib/mg/mg.1
	@@ -0,0 +1,1140 @@
	+.\" $OpenBSD: mg.1,v 1.125 2021/05/02 14:13:17 lum Exp $
	+.\" This file is in the public domain.
	+.\"
	+.Dd $Mdocdate: May 2 2021 $
	+.Dt MG 1
	+.Os
	+.Sh NAME
	+.Nm mg
	+.Nd emacs-like text editor
	+.Sh SYNOPSIS
	+.Nm mg
	+.Op Fl nR
	+.Op Fl b Ar file
	+.Op Fl f Ar mode
	+.Op Fl u Ar file
	+.Op + Ns Ar number
	+.Op Ar
	+.Sh DESCRIPTION
	+.Nm
	+is intended to be a small, fast, and portable editor for
	+people who can't (or don't want to) run emacs for one
	+reason or another, or are not familiar with the
	+.Xr vi 1
	+editor.
	+It is compatible with emacs because there shouldn't
	+be any reason to learn more editor types than emacs or
	+.Xr vi 1 .
	+.Pp
	+The options are as follows:
	+.Bl -tag -width Ds
	+.It + Ns Ar number
	+Go to the line specified by number (do not insert
	+a space between the
	+.Sq +
	+sign and the number).
	+If a negative number is specified, the line number counts
	+backwards from the end of the file i.e. +-1 will be the last
	+line of the file, +-2 will be second last, and so on.
	+.It Fl b Ar file
	+Turn on batch mode and execute the
	+.Nm
	+commands found in the specified
	+.Ar file
	+and then terminate.
	+.It Fl f Ar mode
	+Run the mode command for all buffers created from
	+arguments on the command line, including the
	+scratch buffer and all files.
	+.It Fl n
	+Turn off backup file generation.
	+.It Fl R
	+Files specified on the command line will be opened read-only.
	+.It Fl u Ar file
	+Use
	+.Ar file
	+as the startup file, instead of the default
	+.Pa ~/.mg .
	+.El
	+.Sh WINDOWS AND BUFFERS
	+When a file is loaded into
	+.Nm ,
	+it is stored in a
	+.Em buffer .
	+This buffer may be displayed on the screen in more than one window.
	+At present, windows may only be split horizontally, so each window is
	+delineated by a modeline at the bottom.
	+If changes are made to a buffer, it will be reflected in all open windows.
	+.Pp
	+If a file is changed outside
	+.Nm
	+and its buffer is about to be changed,
	+.Nm
	+prompts if the change should go ahead (y), not go ahead (n) or if the buffer
	+should be reverted (r) to the latest file on disk.
	+.Pp
	+If a buffer name begins and ends with an asterisk, the buffer is considered
	+throwaway; i.e. the user will not be prompted to save changes when
	+the buffer is killed.
	+.Sh POINT AND MARK
	+The current cursor location in
	+.Nm
	+is called the
	+.Em point
	+(or
	+.Em dot ) .
	+It is possible to define a window-specific region of text by setting a second
	+location, called the
	+.Em mark .
	+The
	+.Em region
	+is the text between point and mark inclusive.
	+Deleting the character at the mark position leaves
	+the mark at the point of deletion.
	+.Pp
	+Note: The point and mark are window-specific in
	+.Nm ,
	+not buffer-specific, as in other emacs flavours.
	+.Sh BACKUP FILES
	+Backup files have a
	+.Sq ~
	+character appended to the file name and
	+are created in the current working directory by default.
	+Whether to create backup files or not can be toggled with the
	+make-backup-files command.
	+The backup file location can either be in the current
	+working directory, or all backups can be moved to a
	+.Pa ~/.mg.d
	+directory where files retain their path name to retain uniqueness.
	+Use the backup-to-home-directory to alternate between these two locations.
	+Further, if any application creates backup files in
	+.Pa /tmp ,
	+these can be left with the leave-tmpdir-backups command.
	+.Sh TAGS
	+.Nm
	+supports tag files created by
	+.Xr ctags 1 ,
	+allowing the user to quickly locate various object definitions.
	+Note though that emacs uses etags, not ctags.
	+.Sh CSCOPE
	+.Nm
	+supports navigating source code using cscope.
	+However,
	+.Nm
	+requires cscope and cscope-indexer executables to be present in
	+.Ev PATH
	+for it to work.
	+.Sh DEFAULT KEY BINDINGS
	+Normal editing commands are very similar to GNU Emacs.
	+In the following examples, C-x means Control-x, and M-x means Meta-x,
	+where the Meta key may be either a special key on the keyboard
	+or the ALT key; otherwise ESC followed by the key X works as well.
	+.Pp
	+.Bl -tag -width xxxxxxxxxxxx -offset indent -compact
	+.It C-SPC
	+set-mark-command
	+.It C-a
	+beginning-of-line
	+.It C-b
	+backward-char
	+.It C-c s c
	+cscope-find-functions-calling-this-function
	+.It C-c s d
	+cscope-find-global-definition
	+.It C-c s e
	+cscope-find-egrep-pattern
	+.It C-c s f
	+cscope-find-this-file
	+.It C-c s i
	+cscope-find-files-including-file
	+.It C-c s n
	+cscope-next-symbol
	+.It C-c s p
	+cscope-prev-symbol
	+.It C-c s s
	+cscope-find-this-symbol
	+.It C-c s t
	+cscope-find-this-text-string
	+.It C-d
	+delete-char
	+.It C-e
	+end-of-line
	+.It C-f
	+forward-char
	+.It C-g
	+keyboard-quit
	+.It C-h C-h
	+help-help
	+.It C-h a
	+apropos
	+.It C-h b
	+describe-bindings
	+.It C-h c
	+describe-key-briefly
	+.It C-j
	+newline-and-indent
	+.It C-k
	+kill-line
	+.It C-l
	+recenter
	+.It RET
	+newline
	+.It C-n
	+next-line
	+.It C-o
	+open-line
	+.It C-p
	+previous-line
	+.It C-q
	+quoted-insert
	+.It C-r
	+isearch-backward
	+.It C-s
	+isearch-forward
	+.It C-t
	+transpose-chars
	+.It C-u
	+universal-argument
	+.It C-v
	+scroll-up
	+.It C-w
	+kill-region
	+.It C-x C-b
	+list-buffers
	+.It C-x C-c
	+save-buffers-kill-emacs
	+.It C-x C-f
	+find-file
	+.It C-x C-j
	+dired-jump
	+.It C-x C-g
	+keyboard-quit
	+.It C-x C-l
	+downcase-region
	+.It C-x C-o
	+delete-blank-lines
	+.It C-x C-q
	+toggle-read-only
	+.It C-x C-r
	+find-file-read-only
	+.It C-x C-s
	+save-buffer
	+.It C-x C-u
	+upcase-region
	+.It C-x C-v
	+find-alternate-file
	+.It C-x C-w
	+write-file
	+.It C-x C-x
	+exchange-point-and-mark
	+.It C-x (
	+start-kbd-macro
	+.It C-x \&)
	+end-kbd-macro
	+.It C-x 0
	+delete-window
	+.It C-x 1
	+delete-other-windows
	+.It C-x 2
	+split-window-vertically
	+.It C-x 4 C-f
	+find-file-other-window
	+.It C-x 4 C-g
	+keyboard-quit
	+.It C-x 4 b
	+switch-to-buffer-other-window
	+.It C-x 4 f
	+find-file-other-window
	+.It C-x =
	+what-cursor-position
	+.It C-x ^
	+enlarge-window
	+.It C-x `
	+next-error
	+.It C-x b
	+switch-to-buffer
	+.It C-x d
	+dired
	+.It C-x e
	+call-last-kbd-macro
	+.It C-x f
	+set-fill-column
	+.It C-x g
	+goto-line
	+.It C-x h
	+mark-whole-buffer
	+.It C-x i
	+insert-file
	+.It C-x k
	+kill-buffer
	+.It C-x n
	+other-window
	+.It C-x o
	+other-window
	+.It C-x p
	+previous-window
	+.It C-x s
	+save-some-buffers
	+.It C-x u
	+undo
	+.It C-y
	+yank
	+.It C-z
	+suspend-emacs
	+.It M-C-v
	+scroll-other-window
	+.It M-SPC
	+just-one-space
	+.It M-!
	+shell-command
	+.It M-.
	+find-tag
	+.It M-*
	+pop-tag-mark
	+.It M-%
	+query-replace
	+.It M-<
	+beginning-of-buffer
	+.It M->
	+end-of-buffer
	+.It M-\e
	+delete-horizontal-space
	+.It M-^
	+join-line
	+.It M-b
	+backward-word
	+.It M-c
	+capitalize-word
	+.It M-d
	+kill-word
	+.It M-f
	+forward-word
	+.It M-h
	+mark-paragraph
	+.It M-l
	+downcase-word
	+.It M-m
	+back-to-indentation
	+.It M-q
	+fill-paragraph
	+.It M-r
	+search-backward
	+.It M-s
	+search-forward
	+.It M-t
	+transpose-words
	+.It M-u
	+upcase-word
	+.It M-v
	+scroll-down
	+.It M-w
	+copy-region-as-kill
	+.It M-x
	+execute-extended-command
	+.It M-{
	+backward-paragraph
	+.It M-\|
	+shell-command-on-region
	+.It M-}
	+forward-paragraph
	+.It M-~
	+not-modified
	+.It M-DEL
	+backward-kill-word
	+.It C-_
	+undo
	+.It )
	+blink-and-insert
	+.It DEL
	+delete-backward-char
	+.El
	+.Pp
	+For a complete description of
	+.Nm
	+commands, see
	+.Sx MG COMMANDS .
	+To see the active keybindings at any time, type
	+.Dq M-x describe-bindings .
	+.Sh MG COMMANDS
	+Commands are invoked by
	+.Dq M-x ,
	+or by binding to a key.
	+Many commands take an optional numerical parameter,
	+.Va n .
	+This parameter is set either by
	+M-<n> (where
	+.Va n
	+is the numerical argument) before the command, or by
	+one or more invocations of the universal argument, usually bound to C-u.
	+When invoked in this manner, the value of the numeric parameter to
	+be passed is displayed in the minibuffer before the M-x.
	+One common use of the parameter is in mode toggles (e.g.\&
	+make-backup-files).
	+If no parameter is supplied, the mode is toggled to its
	+alternate state.
	+If a positive parameter is supplied, the mode is forced to on.
	+Otherwise, it is forced to off.
	+.\"
	+.Bl -tag -width xxxxx
	+.It apropos
	+Help Apropos.
	+Prompt the user for a string, open the help buffer,
	+and list all
	+.Nm
	+commands that contain that string.
	+.It audible-bell
	+Toggle the audible system bell.
	+.It auto-execute
	+Register an auto-execute hook; that is, specify a filename pattern
	+(conforming to the shell's filename globbing rules) and an associated
	+function to execute when a file matching the specified pattern
	+is read into a buffer.
	+.It auto-fill-mode
	+Toggle auto-fill mode (sometimes called mail-mode) in the current buffer,
	+where text inserted past the fill column is automatically wrapped
	+to a new line.
	+Can be set globally with set-default-mode.
	+.It auto-indent-mode
	+Toggle indent mode in the current buffer,
	+where indentation is preserved after a newline.
	+Can be set globally with set-default-mode.
	+.It back-to-indentation
	+Move the dot to the first non-whitespace character on the current line.
	+.It backup-to-home-directory
	+Save backup copies to a
	+.Pa ~/.mg.d
	+directory instead of working directory.
	+Requires make-backup-files to be on.
	+.It backward-char
	+Move cursor backwards one character.
	+.It backward-kill-word
	+Kill text backwards by
	+.Va n
	+words.
	+.It backward-paragraph
	+Move cursor backwards
	+.Va n
	+paragraphs.
	+Paragraphs are delimited by <NL><NL> or <NL><TAB> or <NL><SPACE>.
	+.It backward-word
	+Move cursor backwards by the specified number of words.
	+.It beginning-of-buffer
	+Move cursor to the top of the buffer.
	+If set, keep mark's position, otherwise set at current position.
	+A numeric argument
	+.Va n
	+will move n/10th of the way from the top.
	+.It beginning-of-line
	+Move cursor to the beginning of the line.
	+.It blink-and-insert
	+Self-insert a character, then search backwards and blink its
	+matching delimiter.
	+For delimiters other than
	+parenthesis, brackets, and braces, the character itself
	+is used as its own match.
	+Can be used in the startup file with the global-set-key command.
	+.It bsmap-mode
	+Toggle bsmap mode, where DEL and C-h are swapped.
	+.It c-mode
	+Toggle a KNF-compliant mode for editing C program files.
	+.It call-last-kbd-macro
	+Invoke the keyboard macro.
	+.It capitalize-word
	+Capitalize
	+.Va n
	+words; i.e. convert the first character of the word to
	+upper case, and subsequent letters to lower case.
	+.It cd
	+Change the global working directory.
	+See also global-wd-mode.
	+.It column-number-mode
	+Toggle whether the column number is displayed in the modeline.
	+.It copy-region-as-kill
	+Copy all of the characters in the region to the kill buffer,
	+clearing the mark afterwards.
	+This is a bit like a kill-region followed by a yank.
	+.It count-matches
	+Count the number of lines matching the supplied regular expression.
	+.It count-non-matches
	+Count the number of lines not matching the supplied regular expression.
	+.It cscope-find-this-symbol
	+List the matches for the given symbol.
	+.It cscope-find-global-definition
	+List global definitions for the given literal.
	+.It cscope-find-called-functions
	+List functions called from the given function.
	+.It cscope-find-functions-calling-this-function
	+List functions calling the given function.
	+.It cscope-find-this-text-string
	+List locations matching the given text string.
	+.It cscope-find-egrep-pattern
	+List locations matching the given extended regular expression pattern.
	+.It cscope-find-this-file
	+List filenames matching the given filename.
	+.It cscope-find-files-including-file
	+List files that #include the given filename.
	+.It cscope-next-symbol
	+Navigate to the next match.
	+.It cscope-prev-symbol
	+Navigate to the previous match.
	+.It cscope-next-file
	+Navigate to the next file.
	+.It cscope-prev-file
	+Navigate to the previous file.
	+.It cscope-create-list-of-files-to-index
	+Create cscope's List and Index in the given directory.
	+.It define-key
	+Prompts the user for a named keymap (mode),
	+a key, and an
	+.Nm
	+command, then creates a keybinding in the appropriate
	+map.
	+.It delete-backward-char
	+Delete backwards
	+.Va n
	+characters.
	+Like delete-char, this actually does a kill if presented
	+with an argument.
	+.It delete-blank-lines
	+Delete blank lines around dot.
	+If dot is sitting on a blank line, this command
	+deletes all the blank lines above and below the current line.
	+Otherwise, it deletes all of the blank lines after the current line.
	+.It delete-char
	+Delete
	+.Va n
	+characters forward.
	+If any argument is present, it kills rather than deletes,
	+saving the result in the kill buffer.
	+.It delete-horizontal-space
	+Delete any whitespace around the dot.
	+.It delete-leading-space
	+Delete leading whitespace on the current line.
	+.It delete-trailing-space
	+Delete trailing whitespace on the current line.
	+.It delete-matching-lines
	+Delete all lines after dot that contain a string matching
	+the supplied regular expression.
	+.It delete-non-matching-lines
	+Delete all lines after dot that don't contain a string matching
	+the supplied regular expression.
	+.It delete-other-windows
	+Make the current window the only window visible on the screen.
	+.It delete-window
	+Delete current window.
	+.It describe-bindings
	+List all global and local keybindings, putting the result in
	+the help buffer.
	+.It describe-key-briefly
	+Read a key from the keyboard, and look it up in the keymap.
	+Display the name of the function currently bound to the key.
	+.It diff-buffer-with-file
	+View the differences between buffer and its associated file.
	+.It digit-argument
	+Process a numerical argument for keyboard-invoked functions.
	+.It dired-jump
	+Open a dired buffer containing the current buffer's directory location.
	+.It downcase-region
	+Set all characters in the region to lower case.
	+.It downcase-word
	+Set characters to lower case, starting at the dot, and ending
	+.Va n
	+words away.
	+.It emacs-version
	+Return an
	+.Nm
	+version string.
	+.It end-kbd-macro
	+Stop defining a keyboard macro.
	+.It end-of-buffer
	+Move cursor to the end of the buffer.
	+If set, keep mark's position, otherwise set at current position.
	+A numeric argument
	+.Va n
	+will move n/10th of the way from the end.
	+.It end-of-line
	+Move cursor to the end of the line.
	+.It enlarge-window
	+Enlarge the current window by shrinking either the window above
	+or below it.
	+.It eval-current-buffer
	+Evaluate the current buffer as a series of
	+.Nm
	+commands.
	+Useful for testing
	+.Nm
	+startup files.
	+.It eval-expression
	+Get one line from the user, and run it.
	+Useful for testing expressions in
	+.Nm
	+startup files.
	+.It exchange-point-and-mark
	+Swap the values of "dot" and "mark" in the current window.
	+Return an error if no mark is set.
	+.It execute-extended-command
	+Invoke an extended command; i.e. M-x.
	+Call the message line routine to read in the command name and apply
	+autocompletion to it.
	+When it comes back, look the name up in the symbol table and run the
	+command if it is found, passing arguments as necessary.
	+Print an error if there is anything wrong.
	+.It fill-paragraph
	+Justify a paragraph, wrapping text at the current fill column.
	+.It find-file
	+Select a file for editing.
	+First check if the file can be found
	+in another buffer; if it is there, just switch to that buffer.
	+If the file cannot be found, create a new buffer, read in the
	+file from disk, and switch to the new buffer.
	+.It find-file-read-only
	+Same as find-file, except the new buffer is set to read-only.
	+.It find-alternate-file
	+Replace the current file with an alternate one.
	+Semantics for finding the replacement file are the same as
	+find-file, except the current buffer is killed before the switch.
	+If the kill fails, or is aborted, revert to the original file.
	+.It find-file-other-window
	+Opens the specified file in a second buffer.
	+Splits the current window if necessary.
	+.It find-tag
	+Jump to definition of tag at dot.
	+.It forward-char
	+Move cursor forwards (or backwards, if
	+.Va n
	+is negative)
	+.Va n
	+characters.
	+Returns an error if the end of buffer is reached.
	+.It forward-paragraph
	+Move forward
	+.Va n
	+paragraphs.
	+Paragraphs are delimited by <NL><NL> or <NL><TAB> or <NL><SPACE>.
	+.It forward-word
	+Move the cursor forward by the specified number of words.
	+.It global-set-key
	+Bind a key in the global (fundamental) key map.
	+.It global-unset-key
	+Unbind a key from the global (fundamental) key map; i.e. set it to 'rescan'.
	+.It global-wd-mode
	+Toggle global working-directory mode.
	+When enabled,
	+.Nm
	+defaults to opening files (and executing commands like compile and grep)
	+relative to the global working directory.
	+When disabled, a working directory is set for each buffer.
	+.It goto-line
	+Go to a specific line.
	+If an argument is present, then
	+it is the line number, else prompt for a line number to use.
	+.It help-help
	+Prompts for one of (a)propos, (b)indings, des(c)ribe key briefly.
	+.It insert
	+Insert a string, mainly for use from macros.
	+.It insert-buffer
	+Insert the contents of another buffer at dot.
	+.It insert-file
	+Insert a file into the current buffer at dot.
	+.It insert-with-wrap
	+Insert the bound character with word wrap.
	+Check to see if we're past the fill column, and if so,
	+justify this line.
	+.It isearch-backward
	+Use incremental searching, initially in the reverse direction.
	+isearch ignores any explicit arguments.
	+If invoked during macro definition or evaluation, the non-incremental
	+search-backward is invoked instead.
	+.It isearch-forward
	+Use incremental searching, initially in the forward direction.
	+isearch ignores any explicit arguments.
	+If invoked during macro definition or evaluation, the non-incremental
	+search-forward is invoked instead.
	+.It join-line
	+Join the current line to the previous.
	+If called with an argument,
	+join the next line to the current one.
	+.It just-one-space
	+Delete any whitespace around dot, then insert a space.
	+.It keyboard-quit
	+Abort the current action.
	+.It kill-buffer
	+Dispose of a buffer, by name.
	+If the buffer name does not start and end with an asterisk,
	+prompt the user if the buffer
	+has been changed.
	+.It kill-line
	+Kill line.
	+If called without an argument, it kills from dot to the end
	+of the line, unless it is at the end of the line, when it kills the
	+newline.
	+If called with an argument of 0, it kills from the start of the
	+line to dot.
	+If called with a positive argument, it kills from dot
	+forward over that number of newlines.
	+If called with a negative argument
	+it kills any text before dot on the current line, then it kills back
	+abs(n) lines.
	+.It kill-paragraph
	+Delete
	+.Va n
	+paragraphs starting with the current one.
	+.It kill-region
	+Kill the currently defined region.
	+.It kill-word
	+Delete forward
	+.Va n
	+words.
	+.It leave-tmpdir-backups
	+Modifies the behaviour of backup-to-home-directory.
	+Backup files that would normally reside in
	+.Pa /tmp
	+are left there and not moved to the
	+.Pa ~/.mg.d
	+directory.
	+.It line-number-mode
	+Toggle whether the line number is displayed in the modeline.
	+.It list-buffers
	+Display the list of available buffers.
	+The first column in the output indicates which buffer is active with a '>'
	+character.
	+The second column indicates which buffers are modified.
	+The third column indicates which buffers are read-only.
	+The remaining columns are self-explanatory.
	+.It load
	+Prompt the user for a filename, and then execute commands
	+from that file.
	+.It local-set-key
	+Bind a key mapping in the local (topmost) mode.
	+.It local-unset-key
	+Unbind a key mapping in the local (topmost) mode.
	+.It make-backup-files
	+Toggle generation of backup files.
	+Enabled by default.
	+.It make-directory
	+Prompt the user for a path or directory name which is then created.
	+.It mark-paragraph
	+Mark
	+.Va n
	+paragraphs.
	+.It mark-whole-buffer
	+Marks whole buffer as a region by putting dot at the beginning and mark
	+at the end of buffer.
	+.It meta-key-mode
	+When disabled, the meta key can be used to insert extended-ascii (8-bit)
	+characters.
	+When enabled, the meta key acts as usual.
	+.It negative-argument
	+Process a negative argument for keyboard-invoked functions.
	+.It newline
	+Insert a newline into the current buffer.
	+.It newline-and-indent
	+Insert a newline, then enough tabs and spaces to duplicate the indentation
	+of the previous line.
	+Assumes tabs are every eight characters.
	+.It next-line
	+Move forward
	+.Va n
	+lines.
	+.\" .It no-tab-mode
	+.\" Toggle notab mode.
	+.\" In this mode, spaces are inserted rather than tabs.
	+.It not-modified
	+Turn off the modified flag in the current buffer.
	+.It open-line
	+Open up some blank space.
	+Essentially, insert
	+.Va n
	+newlines, then back up over them.
	+.It other-window
	+The command to make the next (down the screen) window the current
	+window.
	+There are no real errors, although the command does nothing if
	+there is only 1 window on the screen.
	+.It overwrite-mode
	+Toggle overwrite mode in the current buffer,
	+where typing overwrites existing characters rather than inserting them.
	+Can be set globally with set-default-mode.
	+.It prefix-region
	+Inserts a prefix string before each line of a region.
	+The prefix string is settable by using 'set-prefix-string'.
	+.It previous-line
	+Move backwards
	+.Va n
	+lines.
	+.It previous-window
	+This command makes the previous (up the screen) window the
	+current window.
	+There are no errors, although the command does not do
	+a lot if there is only 1 window.
	+.It pop-tag-mark
	+Return to position where find-tag was previously invoked.
	+.It push-shell
	+Suspend
	+.Nm
	+and switch to alternate screen, if available.
	+.It pwd
	+Display current (global) working directory in the status area.
	+.It query-replace
	+Query Replace.
	+Search and replace strings selectively, prompting after each match.
	+.It replace-regexp
	+Replace regular expression globally without individual prompting.
	+.It replace-string
	+Replace string globally without individual prompting.
	+.It query-replace-regexp
	+Replace strings selectively.
	+Does a search and replace operation using regular
	+expressions for both patterns.
	+.It quoted-insert
	+Insert the next character verbatim into the current buffer; i.e. ignore
	+any function bound to that key.
	+.It re-search-again
	+Perform a regular expression search again, using the same search
	+string and direction as the last search command.
	+.It re-search-backward
	+Search backwards using a regular expression.
	+Get a search string from the user, and search, starting at dot
	+and proceeding toward the front of the buffer.
	+If found, dot is left
	+pointing at the first character of the pattern [the last character that
	+was matched].
	+.It re-search-forward
	+Search forward using a regular expression.
	+Get a search string from the user and search for it starting at dot.
	+If found, move dot to just after the matched characters.
	+display does all
	+the hard stuff.
	+If not found, it just prints a message.
	+.It recenter
	+Reposition dot in the current window.
	+By default, the dot is centered.
	+If given a positive argument (n), the display is repositioned to line
	+n.
	+If
	+.Va n
	+is negative, it is that line from the bottom.
	+.It redraw-display
	+Refresh the display.
	+Recomputes all window sizes in case something has changed.
	+.It revert-buffer
	+Revert the current buffer to the latest file on disk.
	+.It save-buffer
	+Save the contents of the current buffer if it has been changed,
	+optionally creating a backup copy.
	+.It save-buffers-kill-emacs
	+Offer to save modified buffers and quit
	+.Nm .
	+.It save-some-buffers
	+Look through the list of buffers, offering to save any buffer that
	+has been changed.
	+Buffers that are not associated with files (such
	+as scratch, grep, compile) are ignored.
	+.It scroll-down
	+Scroll backwards
	+.Va n
	+pages.
	+A two-line overlap between pages is
	+assumed.
	+If given a repeat argument, scrolls back lines, not pages.
	+.It scroll-one-line-down
	+Scroll the display down
	+.Va n
	+lines without changing the cursor position.
	+.It scroll-one-line-up
	+Scroll the display
	+.Va n
	+lines up without moving the cursor position.
	+.It scroll-other-window
	+Scroll the next window in the window list window forward
	+.Va n
	+pages.
	+.It scroll-up
	+Scroll forward one page.
	+A two-line overlap between pages is
	+assumed.
	+If given a repeat argument, scrolls back lines, not pages.
	+.It search-again
	+Search again, using the same search string and direction as the last
	+search command.
	+.It search-backward
	+Reverse search.
	+Get a search string from the user, and search, starting
	+at dot and proceeding toward the front of the buffer.
	+If found, dot is
	+left pointing at the first character of the pattern (the last character
	+that was matched).
	+.It search-forward
	+Search forward.
	+Get a search string from the user, and search for it
	+starting at dot.
	+If found, dot gets moved to just after the matched
	+characters, if not found, print a message.
	+.It self-insert-command
	+Insert a character.
	+.It sentence-end-double-space
	+Toggle double or single spaces for end of sentences.
	+Double is the default.
	+Currently only affects fill-paragraph.
	+.It set-case-fold-search
	+Set case-fold searching, causing case not to matter
	+in regular expression searches.
	+This is the default.
	+.It set-case-replace
	+Preserve the case of the replaced string.
	+This is the default.
	+.It set-default-mode
	+Append the supplied mode to the list of default modes
	+used by subsequent buffer creation.
	+Built in modes include: fill, indent and overwrite.
	+.It set-fill-column
	+Prompt the user for a fill column.
	+Used by auto-fill-mode.
	+.It set-mark-command
	+Sets the mark in the current window to the current dot location.
	+.It set-prefix-string
	+Sets the prefix string to be used by the 'prefix-region' command.
	+.It shell-command
	+Execute external command from mini-buffer.
	+.It shell-command-on-region
	+Provide the text in region to the shell command as input.
	+.It shrink-window
	+Shrink current window by one line.
	+The window immediately below is expanded to pick up the slack.
	+If only one window is present, this command has no effect.
	+.It split-window-vertically
	+Split the current window.
	+A window smaller than 3 lines cannot be split.
	+.It start-kbd-macro
	+Start defining a keyboard macro.
	+Macro definition is ended by invoking end-kbd-macro.
	+.It suspend-emacs
	+Suspend
	+.Nm
	+and switch back to alternate screen, if in use.
	+.It switch-to-buffer
	+Prompt and switch to a new buffer in the current window.
	+.It switch-to-buffer-other-window
	+Switch to buffer in another window.
	+.It toggle-read-only
	+Toggle the read-only flag on the current buffer.
	+.It toggle-read-only-all
	+Toggle the read-only flag on all non-ephemeral buffers.
	+A simple toggle that switches a global read-only flag either on
	+or off.
	+.It transpose-chars
	+Transpose the two characters in front of and under dot,
	+then move forward one character.
	+Treat newline characters the same as any other.
	+.It transpose-paragraphs
	+Transpose adjacent paragraphs.
	+If multiple iterations are requested, the current paragraph will
	+be moved
	+.Va n
	+paragraphs forward.
	+.It transpose-words
	+Transpose adjacent words.
	+.It undo
	+Undo the most recent action.
	+If invoked again without an intervening command,
	+move the undo pointer to the previous action and undo it.
	+.It undo-boundary
	+Add an undo boundary.
	+This is not usually done interactively.
	+.It undo-boundary-toggle
	+Toggle whether undo boundaries are generated.
	+Undo boundaries are often disabled before operations that should
	+be considered atomically undoable.
	+.It undo-enable
	+Toggle whether undo information is kept.
	+.It undo-list
	+Show the undo records for the current buffer in a new buffer.
	+.It universal-argument
	+Repeat the next command 4 times.
	+Usually bound to C-u.
	+This command may be stacked; e.g.\&
	+C-u C-u C-f moves the cursor forward 16 characters.
	+.It upcase-region
	+Upper case region.
	+Change all of the lower case characters in the region to
	+upper case.
	+.It upcase-word
	+Move the cursor forward by the specified number of words.
	+As it moves, convert any characters to upper case.
	+.It visible-bell
	+Toggle the visible bell.
	+If this toggle is on, the modeline will flash.
	+.It visit-tags-table
	+Record name of the tags file to be used for subsequent find-tag.
	+.It what-cursor-position
	+Display a bunch of useful information about the current location of
	+dot.
	+The character under the cursor (in octal), the current line, row,
	+and column, and approximate position of the cursor in the file (as a
	+percentage) is displayed.
	+The column position assumes an infinite
	+position display; it does not truncate just because the screen does.
	+.It write-file
	+Ask for a file name and write the contents of the current buffer to
	+that file.
	+Update the remembered file name and clear the buffer
	+changed flag.
	+.It yank
	+Yank text from kill-buffer.
	+Unlike emacs, the
	+.Nm
	+kill buffer consists only
	+of the most recent kill.
	+It is not a ring.
	+.El
	+.Sh MG DIRED KEY BINDINGS
	+Specific key bindings are available in dired mode.
	+.Pp
	+.Bl -tag -width xxxxxxxxxxxxxxxxxx -offset indent -compact
	+.It DEL
	+dired-unmark-backward
	+.It RET, e, f and C-m
	+dired-find-file
	+.It SPC, n
	+dired-next-line
	+.It !
	+dired-shell-command
	+.It +
	+dired-create-directory
	+.It a
	+dired-find-alternate-file
	+.It c
	+dired-do-copy
	+.It d and C-d
	+dired-flag-file-deletion
	+.It g
	+dired-revert
	+.It j
	+dired-goto-file
	+.It o
	+dired-find-file-other-window
	+.It p
	+dired-previous-line
	+.It q
	+quit-window
	+.It r
	+dired-do-rename
	+.It u
	+dired-unmark
	+.It x
	+dired-do-flagged-delete
	+.It C-v
	+dired-scroll-down
	+.It M-v
	+dired-scroll-up
	+.El
	+.Sh MG DIRED COMMANDS
	+The following are a list of the commands specific to dired mode:
	+.Bl -tag -width Ds
	+.It dired-create-directory
	+Create a directory.
	+.It dired-do-copy
	+Copy the file listed on the current line of the dired buffer.
	+.It dired-do-flagged-delete
	+Delete the files that have been flagged for deletion.
	+.It dired-do-rename
	+Rename the file listed on the current line of the dired buffer.
	+.It dired-find-alternate-file
	+Replace the current dired buffer with an alternate one as specified
	+by the position of the cursor in the dired buffer.
	+.It dired-find-file
	+Open the file on the current line of the dired buffer.
	+If the cursor is on a directory it will be opened in dired mode.
	+.It dired-flag-file-deletion
	+Flag the file listed on the current line for deletion.
	+This is indicated in the buffer by putting a D at the left margin.
	+No files are actually deleted until the function dired-do-flagged-delete
	+is executed.
	+.It dired-find-file-other-window
	+Open the file on the current line of the dired buffer in a
	+different window.
	+.It dired-goto-file
	+Move the cursor to a file name in the dired buffer.
	+.It dired-next-line
	+Move the cursor to the next line.
	+.It dired-other-window
	+This function works just like dired, except that it puts the
	+dired buffer in another window.
	+.It dired-previous-line
	+Move the cursor to the previous line.
	+.It dired-revert
	+Refresh the dired buffer while retaining any flags.
	+.It dired-scroll-down
	+Scroll down the dired buffer.
	+.It dired-scroll-up
	+Scroll up the dired buffer.
	+.It dired-shell-command
	+Pipe the file under the current cursor position through a shell command.
	+.It dired-unmark
	+Remove the deletion flag for the file on the current line.
	+.It dired-unmark-backward
	+Remove the deletion flag from the file listed on the previous line
	+of the dired buffer, then move up to that line.
	+.It quit-window
	+Close the current dired buffer.
	+.El
	+.Sh CONFIGURATION FILES
	+There are two configuration files,
	+.Pa .mg
	+and
	+.Pa .mg-TERM .
	+Here,
	+.Ev TERM
	+represents the name of the terminal type; e.g. if the terminal type
	+is set to
	+.Dq vt100 ,
	+.Nm
	+will use
	+.Pa .mg-vt100
	+as a startup file.
	+The terminal type startup file is used first.
	+.Pp
	+The startup file format is a list of commands, one per line, as used for
	+interactive evaluation.
	+Strings that are normally entered by the user at any subsequent prompts
	+may be specified after the command name; e.g.:
	+.Bd -literal -offset indent
	+global-set-key ")" self-insert-command
	+global-set-key "\e^x\e^f" find-file
	+global-set-key "\ee[Z" backward-char
	+set-default-mode fill
	+set-fill-column 72
	+auto-execute *.c c-mode
	+.Ed
	+.Pp
	+Comments can be added to the startup files by placing
	+.Sq ;\&
	+or
	+.Sq #
	+as the first character of a line.
	+.Sh FILES
	+.Bl -tag -width /usr/share/doc/mg/tutorial -compact
	+.It Pa ~/.mg
	+normal startup file
	+.It Pa ~/.mg-TERM
	+terminal-specific startup file
	+.It Pa ~/.mg.d
	+alternative backup file location
	+.It Pa /usr/share/doc/mg/tutorial
	+concise tutorial
	+.El
	+.Sh SEE ALSO
	+.Xr ctags 1 ,
	+.Xr vi 1
	+.Sh CAVEATS
	+Since it is written completely in C, there is currently no
	+language in which extensions can be written;
	+however, keys can be rebound and certain parameters can be changed
	+in startup files.
	+.Pp
	+In order to use 8-bit characters (such as German umlauts), the Meta key
	+needs to be disabled via the
	+.Dq meta-key-mode
	+command.
	+.Pp
	+Multi-byte character sets, such as UTF-8, are not supported.
	Index: contrib/mg/mi_vector_hash.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/mi_vector_hash.c
	@@ -0,0 +1,168 @@
	+/* $NetBSD: mi_vector_hash.c,v 1.1 2013/12/11 01:24:08 joerg Exp $ */
	+/*-
	+ * Copyright (c) 2009 The NetBSD Foundation, Inc.
	+ * All rights reserved.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Joerg Sonnenberger.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ *
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in
	+ * the documentation and/or other materials provided with the
	+ * distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
	+ * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
	+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
	+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	+ * SUCH DAMAGE.
	+ */
	+
	+/*
	+ * See http://burtleburtle.net/bob/hash/doobs.html for the full description
	+ * and the original version of the code. This version differs by exposing
	+ * the full internal state and avoiding byte operations in the inner loop
	+ * if the key is aligned correctly.
	+ */
	+
	+#include <sys/cdefs.h>
	+
	+#include <stdint.h>
	+#include <stdlib.h>
	+
	+#define mix(a, b, c) do { \
	+ a -= b; a -= c; a ^= (c >> 13); \
	+ b -= c; b -= a; b ^= (a << 8); \
	+ c -= a; c -= b; c ^= (b >> 13); \
	+ a -= b; a -= c; a ^= (c >> 12); \
	+ b -= c; b -= a; b ^= (a << 16); \
	+ c -= a; c -= b; c ^= (b >> 5); \
	+ a -= b; a -= c; a ^= (c >> 3); \
	+ b -= c; b -= a; b ^= (a << 10); \
	+ c -= a; c -= b; c ^= (b >> 15); \
	+} while (/* CONSTCOND */0)
	+
	+#define FIXED_SEED 0x9e3779b9 /* Golden ratio, arbitrary constant */
	+
	+/* From NetBSD sys/external/bsd/libnv/dist/nv_compat.h */
	+static uint32_t
	+le32dec(const void *buf)
	+{
	+ uint8_t const p = (uint8_t const ) buf;
	+
	+ return (((unsigned) p[3] << 24) \| (p[2] << 16) \| (p[1] << 8) \| p[0]);
	+}
	+
	+void
	+mi_vector_hash(const void * __restrict key, size_t len, uint32_t seed,
	+ uint32_t hashes[3])
	+{
	+ static const uint32_t mask[4] = {
	+ 0x000000ff, 0x0000ffff, 0x00ffffff, 0xffffffff
	+ };
	+ uint32_t orig_len, a, b, c;
	+ const uint8_t *k;
	+
	+ orig_len = (uint32_t)len;
	+
	+ a = b = FIXED_SEED;
	+ c = seed;
	+
	+ if ((uintptr_t)key & 3) {
	+ k = key;
	+ while (len >= 12) {
	+ a += le32dec(k);
	+ b += le32dec(k + 4);
	+ c += le32dec(k + 8);
	+ mix(a, b, c);
	+ k += 12;
	+ len -= 12;
	+ }
	+ c += orig_len;
	+
	+ if (len > 8) {
	+ switch (len) {
	+ case 11:
	+ c += (uint32_t)k[10] << 24;
	+ /* FALLTHROUGH */
	+ case 10:
	+ c += (uint32_t)k[9] << 16;
	+ /* FALLTHROUGH */
	+ case 9:
	+ c += (uint32_t)k[8] << 8;
	+ /* FALLTHROUGH */
	+ }
	+ b += le32dec(k + 4);
	+ a += le32dec(k);
	+ } else if (len > 4) {
	+ switch (len) {
	+ case 8:
	+ b += (uint32_t)k[7] << 24;
	+ /* FALLTHROUGH */
	+ case 7:
	+ b += (uint32_t)k[6] << 16;
	+ /* FALLTHROUGH */
	+ case 6:
	+ b += (uint32_t)k[5] << 8;
	+ /* FALLTHROUGH */
	+ case 5:
	+ b += k[4];
	+ /* FALLTHROUGH */
	+ }
	+ a += le32dec(k);
	+ } else if (len) {
	+ switch (len) {
	+ case 4:
	+ a += (uint32_t)k[3] << 24;
	+ /* FALLTHROUGH */
	+ case 3:
	+ a += (uint32_t)k[2] << 16;
	+ /* FALLTHROUGH */
	+ case 2:
	+ a += (uint32_t)k[1] << 8;
	+ /* FALLTHROUGH */
	+ case 1:
	+ a += k[0];
	+ /* FALLTHROUGH */
	+ }
	+ }
	+ } else {
	+ const uint32_t *key32 = key;
	+ while (len >= 12) {
	+ a += le32toh(key32[0]);
	+ b += le32toh(key32[1]);
	+ c += le32toh(key32[2]);
	+ mix(a, b, c);
	+ key32 += 3;
	+ len -= 12;
	+ }
	+ c += orig_len;
	+
	+ if (len > 8) {
	+ c += (le32toh(key32[2]) & mask[len - 9]) << 8;
	+ b += le32toh(key32[1]);
	+ a += le32toh(key32[0]);
	+ } else if (len > 4) {
	+ b += le32toh(key32[1]) & mask[len - 5];
	+ a += le32toh(key32[0]);
	+ } else if (len)
	+ a += le32toh(key32[0]) & mask[len - 1];
	+ }
	+ mix(a, b, c);
	+ hashes[0] = a;
	+ hashes[1] = b;
	+ hashes[2] = c;
	+}
	Index: contrib/mg/modes.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/modes.c
	@@ -0,0 +1,174 @@
	+/* $OpenBSD: modes.c,v 1.21 2017/05/30 07:05:22 florian Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * Commands to toggle modes. Without an argument, these functions will
	+ * toggle the given mode. A negative or zero argument will turn the mode
	+ * off. A positive argument will turn the mode on.
	+ */
	+
	+#include <sys/queue.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <string.h>
	+
	+#include "def.h"
	+#include "kbd.h"
	+
	+int changemode(int, int, char *);
	+
	+int defb_nmodes = 0;
	+struct maps_s *defb_modes[PBMODES] = { &fundamental_mode };
	+int defb_flag = 0;
	+
	+int
	+changemode(int f, int n, char *newmode)
	+{
	+ int i;
	+ struct maps_s *m;
	+
	+ if ((m = name_mode(newmode)) == NULL) {
	+ dobeep();
	+ ewprintf("Can't find mode %s", newmode);
	+ return (FALSE);
	+ }
	+ if (!(f & FFARG)) {
	+ for (i = 0; i <= curbp->b_nmodes; i++)
	+ if (curbp->b_modes[i] == m) {
	+ /* mode already set */
	+ n = 0;
	+ break;
	+ }
	+ }
	+ if (n > 0) {
	+ for (i = 0; i <= curbp->b_nmodes; i++)
	+ if (curbp->b_modes[i] == m)
	+ /* mode already set */
	+ return (TRUE);
	+ if (curbp->b_nmodes >= PBMODES - 1) {
	+ dobeep();
	+ ewprintf("Too many modes");
	+ return (FALSE);
	+ }
	+ curbp->b_modes[++(curbp->b_nmodes)] = m;
	+ } else {
	+ /* fundamental is b_modes[0] and can't be unset */
	+ for (i = 1; i <= curbp->b_nmodes && m != curbp->b_modes[i];
	+ i++);
	+ if (i > curbp->b_nmodes)
	+ return (TRUE); /* mode wasn't set */
	+ for (; i < curbp->b_nmodes; i++)
	+ curbp->b_modes[i] = curbp->b_modes[i + 1];
	+ curbp->b_nmodes--;
	+ }
	+ upmodes(curbp);
	+ return (TRUE);
	+}
	+
	+int
	+indentmode(int f, int n)
	+{
	+ return (changemode(f, n, "indent"));
	+}
	+
	+int
	+fillmode(int f, int n)
	+{
	+ return (changemode(f, n, "fill"));
	+}
	+
	+#ifdef NOTAB
	+int
	+notabmode(int f, int n)
	+{
	+ if (changemode(f, n, "notab") == FALSE)
	+ return (FALSE);
	+ if (f & FFARG) {
	+ if (n <= 0)
	+ curbp->b_flag &= ~BFNOTAB;
	+ else
	+ curbp->b_flag \|= BFNOTAB;
	+ } else
	+ curbp->b_flag ^= BFNOTAB;
	+ return (TRUE);
	+}
	+#endif /* NOTAB */
	+
	+int
	+overwrite_mode(int f, int n)
	+{
	+ if (changemode(f, n, "overwrite") == FALSE)
	+ return (FALSE);
	+ if (f & FFARG) {
	+ if (n <= 0)
	+ curbp->b_flag &= ~BFOVERWRITE;
	+ else
	+ curbp->b_flag \|= BFOVERWRITE;
	+ } else
	+ curbp->b_flag ^= BFOVERWRITE;
	+ return (TRUE);
	+}
	+
	+int
	+set_default_mode(int f, int n)
	+{
	+ int i;
	+ struct maps_s *m;
	+ char modebuf[32], *bufp;
	+
	+ if ((bufp = eread("Set Default Mode: ", modebuf, sizeof(modebuf),
	+ EFNEW)) == NULL)
	+ return (ABORT);
	+ else if (bufp[0] == '\0')
	+ return (FALSE);
	+ if ((m = name_mode(modebuf)) == NULL) {
	+ dobeep();
	+ ewprintf("can't find mode %s", modebuf);
	+ return (FALSE);
	+ }
	+ if (!(f & FFARG)) {
	+ for (i = 0; i <= defb_nmodes; i++)
	+ if (defb_modes[i] == m) {
	+ /* mode already set */
	+ n = 0;
	+ break;
	+ }
	+ }
	+ if (n > 0) {
	+ for (i = 0; i <= defb_nmodes; i++)
	+ if (defb_modes[i] == m)
	+ /* mode already set */
	+ return (TRUE);
	+ if (defb_nmodes >= PBMODES - 1) {
	+ dobeep();
	+ ewprintf("Too many modes");
	+ return (FALSE);
	+ }
	+ defb_modes[++defb_nmodes] = m;
	+ } else {
	+ /* fundamental is defb_modes[0] and can't be unset */
	+ for (i = 1; i <= defb_nmodes && m != defb_modes[i]; i++);
	+ if (i > defb_nmodes)
	+ /* mode was not set */
	+ return (TRUE);
	+ for (; i < defb_nmodes; i++)
	+ defb_modes[i] = defb_modes[i + 1];
	+ defb_nmodes--;
	+ }
	+ if (strcmp(modebuf, "overwrite") == 0) {
	+ if (n <= 0)
	+ defb_flag &= ~BFOVERWRITE;
	+ else
	+ defb_flag \|= BFOVERWRITE;
	+ }
	+#ifdef NOTAB
	+ if (strcmp(modebuf, "notab") == 0) {
	+ if (n <= 0)
	+ defb_flag &= ~BFNOTAB;
	+ else
	+ defb_flag \|= BFNOTAB;
	+ }
	+#endif /* NOTAB */
	+ return (TRUE);
	+}
	Index: contrib/mg/nbperf-bdz.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/nbperf-bdz.c
	@@ -0,0 +1,302 @@
	+/* $NetBSD: nbperf-bdz.c,v 1.9 2014/04/30 21:04:58 joerg Exp $ */
	+/*-
	+ * Copyright (c) 2009, 2012 The NetBSD Foundation, Inc.
	+ * All rights reserved.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Joerg Sonnenberger.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ *
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in
	+ * the documentation and/or other materials provided with the
	+ * distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
	+ * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
	+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
	+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	+ * SUCH DAMAGE.
	+ */
	+
	+#include <sys/cdefs.h>
	+
	+#include <err.h>
	+#include <inttypes.h>
	+#include <stdlib.h>
	+#include <stdio.h>
	+#include <string.h>
	+
	+#include "nbperf.h"
	+
	+/*
	+ * A full description of the algorithm can be found in:
	+ * "Simple and Space-Efficient Minimal Perfect Hash Functions"
	+ * by Botelho, Pagh and Ziviani, proceeedings of WADS 2007.
	+ */
	+
	+/*
	+ * The algorithm is based on random, acyclic 3-graphs.
	+ *
	+ * Each edge in the represents a key. The vertices are the reminder of
	+ * the hash function mod n. n = cm with c > 1.23. This ensures that
	+ * an acyclic graph can be found with a very high probality.
	+ *
	+ * An acyclic graph has an edge order, where at least one vertex of
	+ * each edge hasn't been seen before. It is declares the first unvisited
	+ * vertex as authoritive for the edge and assigns a 2bit value to unvisited
	+ * vertices, so that the sum of all vertices of the edge modulo 4 is
	+ * the index of the authoritive vertex.
	+ */
	+
	+#include "graph3.h"
	+
	+struct state {
	+ struct graph3 graph;
	+ uint32_t *visited;
	+ uint32_t *holes64k;
	+ uint16_t *holes64;
	+ uint8_t *g;
	+ uint32_t *result_map;
	+};
	+
	+static void
	+assign_nodes(struct state *state)
	+{
	+ struct edge3 *e;
	+ size_t i, j;
	+ uint32_t t, r, holes;
	+
	+ for (i = 0; i < state->graph.v; ++i)
	+ state->g[i] = 3;
	+
	+ for (i = 0; i < state->graph.e; ++i) {
	+ j = state->graph.output_order[i];
	+ e = &state->graph.edges[j];
	+ if (!state->visited[e->left]) {
	+ r = 0;
	+ t = e->left;
	+ } else if (!state->visited[e->middle]) {
	+ r = 1;
	+ t = e->middle;
	+ } else {
	+ if (state->visited[e->right])
	+ abort();
	+ r = 2;
	+ t = e->right;
	+ }
	+
	+ state->visited[t] = 2 + j;
	+ if (state->visited[e->left] == 0)
	+ state->visited[e->left] = 1;
	+ if (state->visited[e->middle] == 0)
	+ state->visited[e->middle] = 1;
	+ if (state->visited[e->right] == 0)
	+ state->visited[e->right] = 1;
	+
	+ state->g[t] = (9 + r - state->g[e->left] - state->g[e->middle]
	+ - state->g[e->right]) % 3;
	+ }
	+
	+ holes = 0;
	+ for (i = 0; i < state->graph.v; ++i) {
	+ if (i % 65536 == 0)
	+ state->holes64k[i >> 16] = holes;
	+
	+ if (i % 64 == 0)
	+ state->holes64[i >> 6] = holes - state->holes64k[i >> 16];
	+
	+ if (state->visited[i] > 1) {
	+ j = state->visited[i] - 2;
	+ state->result_map[j] = i - holes;
	+ }
	+
	+ if (state->g[i] == 3)
	+ ++holes;
	+ }
	+}
	+
	+static void
	+print_hash(struct nbperf nbperf, struct state state)
	+{
	+ uint64_t sum;
	+ size_t i;
	+
	+ fprintf(nbperf->output, "#include <stdlib.h>\n");
	+ fprintf(nbperf->output, "#include <strings.h>\n\n");
	+
	+ fprintf(nbperf->output, "%suint32_t\n",
	+ nbperf->static_hash ? "static " : "");
	+ fprintf(nbperf->output,
	+ "%s(const void * __restrict key, size_t keylen)\n",
	+ nbperf->hash_name);
	+ fprintf(nbperf->output, "{\n");
	+
	+ fprintf(nbperf->output,
	+ "\tstatic const uint64_t g1[%" PRId32 "] = {\n",
	+ (state->graph.v + 63) / 64);
	+ sum = 0;
	+ for (i = 0; i < state->graph.v; ++i) {
	+ sum \|= ((uint64_t)state->g[i] & 1) << (i & 63);
	+ if (i % 64 == 63) {
	+ fprintf(nbperf->output, "%s0x%016" PRIx64 "ULL,%s",
	+ (i / 64 % 2 == 0 ? "\t " : " "),
	+ sum,
	+ (i / 64 % 2 == 1 ? "\n" : ""));
	+ sum = 0;
	+ }
	+ }
	+ if (i % 64 != 0) {
	+ fprintf(nbperf->output, "%s0x%016" PRIx64 "ULL,%s",
	+ (i / 64 % 2 == 0 ? "\t " : " "),
	+ sum,
	+ (i / 64 % 2 == 1 ? "\n" : ""));
	+ }
	+ fprintf(nbperf->output, "%s\t};\n", (i % 2 ? "\n" : ""));
	+
	+ fprintf(nbperf->output,
	+ "\tstatic const uint64_t g2[%" PRId32 "] = {\n",
	+ (state->graph.v + 63) / 64);
	+ sum = 0;
	+ for (i = 0; i < state->graph.v; ++i) {
	+ sum \|= (((uint64_t)state->g[i] & 2) >> 1) << (i & 63);
	+ if (i % 64 == 63) {
	+ fprintf(nbperf->output, "%s0x%016" PRIx64 "ULL,%s",
	+ (i / 64 % 2 == 0 ? "\t " : " "),
	+ sum,
	+ (i / 64 % 2 == 1 ? "\n" : ""));
	+ sum = 0;
	+ }
	+ }
	+ if (i % 64 != 0) {
	+ fprintf(nbperf->output, "%s0x%016" PRIx64 "ULL,%s",
	+ (i / 64 % 2 == 0 ? "\t " : " "),
	+ sum,
	+ (i / 64 % 2 == 1 ? "\n" : ""));
	+ }
	+ fprintf(nbperf->output, "%s\t};\n", (i % 2 ? "\n" : ""));
	+
	+ fprintf(nbperf->output,
	+ "\tstatic const uint32_t holes64k[%" PRId32 "] = {\n",
	+ (state->graph.v + 65535) / 65536);
	+ for (i = 0; i < state->graph.v; i += 65536)
	+ fprintf(nbperf->output, "%s0x%08" PRIx32 ",%s",
	+ (i / 65536 % 4 == 0 ? "\t " : " "),
	+ state->holes64k[i >> 16],
	+ (i / 65536 % 4 == 3 ? "\n" : ""));
	+ fprintf(nbperf->output, "%s\t};\n", (i / 65536 % 4 ? "\n" : ""));
	+
	+ fprintf(nbperf->output,
	+ "\tstatic const uint16_t holes64[%" PRId32 "] = {\n",
	+ (state->graph.v + 63) / 64);
	+ for (i = 0; i < state->graph.v; i += 64)
	+ fprintf(nbperf->output, "%s0x%04" PRIx32 ",%s",
	+ (i / 64 % 4 == 0 ? "\t " : " "),
	+ state->holes64[i >> 6],
	+ (i / 64 % 4 == 3 ? "\n" : ""));
	+ fprintf(nbperf->output, "%s\t};\n", (i / 64 % 4 ? "\n" : ""));
	+
	+ fprintf(nbperf->output, "\tuint64_t m;\n");
	+ fprintf(nbperf->output, "\tuint32_t idx, i, idx2;\n");
	+ fprintf(nbperf->output, "\tuint32_t h[%zu];\n\n", nbperf->hash_size);
	+
	+ (*nbperf->print_hash)(nbperf, "\t", "key", "keylen", "h");
	+
	+ fprintf(nbperf->output, "\n\th[0] = h[0] %% %" PRIu32 ";\n",
	+ state->graph.v);
	+ fprintf(nbperf->output, "\th[1] = h[1] %% %" PRIu32 ";\n",
	+ state->graph.v);
	+ fprintf(nbperf->output, "\th[2] = h[2] %% %" PRIu32 ";\n",
	+ state->graph.v);
	+
	+ fprintf(nbperf->output,
	+ "\tidx = 9 + ((g1[h[0] >> 6] >> (h[0] & 63)) &1)\n"
	+ "\t + ((g1[h[1] >> 6] >> (h[1] & 63)) & 1)\n"
	+ "\t + ((g1[h[2] >> 6] >> (h[2] & 63)) & 1)\n"
	+ "\t - ((g2[h[0] >> 6] >> (h[0] & 63)) & 1)\n"
	+ "\t - ((g2[h[1] >> 6] >> (h[1] & 63)) & 1)\n"
	+ "\t - ((g2[h[2] >> 6] >> (h[2] & 63)) & 1);\n"
	+ );
	+
	+ fprintf(nbperf->output,
	+ "\tidx = h[idx %% 3];\n");
	+ fprintf(nbperf->output,
	+ "\tidx2 = idx - holes64[idx >> 6] - holes64k[idx >> 16];\n"
	+ "\tidx2 -= popcount64(g1[idx >> 6] & g2[idx >> 6]\n"
	+ "\t & (((uint64_t)1 << (idx & 63)) - 1));\n"
	+ "\treturn idx2;\n");
	+
	+ fprintf(nbperf->output, "}\n");
	+
	+ if (nbperf->map_output != NULL) {
	+ for (i = 0; i < state->graph.e; ++i)
	+ fprintf(nbperf->map_output, "%" PRIu32 "\n",
	+ state->result_map[i]);
	+ }
	+}
	+
	+int
	+bpz_compute(struct nbperf *nbperf)
	+{
	+ struct state state;
	+ int retval = -1;
	+ uint32_t v, e;
	+
	+ if (nbperf->c == 0)
	+ nbperf->c = 1.24;
	+ if (nbperf->c < 1.24)
	+ errx(1, "The argument for option -c must be at least 1.24");
	+ if (nbperf->hash_size < 3)
	+ errx(1, "The hash function must generate at least 3 values");
	+
	+ (*nbperf->seed_hash)(nbperf);
	+ e = nbperf->n;
	+ v = nbperf->c * nbperf->n;
	+ if (1.24 * nbperf->n > v)
	+ ++v;
	+ if (v < 10)
	+ v = 10;
	+
	+ graph3_setup(&state.graph, v, e);
	+
	+ state.holes64k = calloc(sizeof(uint32_t), (v + 65535) / 65536);
	+ state.holes64 = calloc(sizeof(uint16_t), (v + 63) / 64 );
	+ state.g = calloc(sizeof(uint32_t), v \| 63);
	+ state.visited = calloc(sizeof(uint32_t), v);
	+ state.result_map = calloc(sizeof(uint32_t), e);
	+
	+ if (state.holes64k == NULL \|\| state.holes64 == NULL \|\|
	+ state.g == NULL \|\| state.visited == NULL \|\|
	+ state.result_map == NULL)
	+ err(1, "malloc failed");
	+
	+ if (graph3_hash(nbperf, &state.graph))
	+ goto failed;
	+ if (graph3_output_order(&state.graph))
	+ goto failed;
	+ assign_nodes(&state);
	+ print_hash(nbperf, &state);
	+
	+ retval = 0;
	+
	+failed:
	+ graph3_free(&state.graph);
	+ free(state.visited);
	+ free(state.g);
	+ free(state.holes64k);
	+ free(state.holes64);
	+ free(state.result_map);
	+ return retval;
	+}
	Index: contrib/mg/nbperf-chm.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/nbperf-chm.c
	@@ -0,0 +1,268 @@
	+/* $NetBSD: nbperf-chm.c,v 1.3 2011/10/21 23:47:11 joerg Exp $ */
	+/*-
	+ * Copyright (c) 2009 The NetBSD Foundation, Inc.
	+ * All rights reserved.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Joerg Sonnenberger.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ *
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in
	+ * the documentation and/or other materials provided with the
	+ * distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
	+ * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
	+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
	+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	+ * SUCH DAMAGE.
	+ */
	+
	+#include <sys/cdefs.h>
	+
	+#include <err.h>
	+#include <inttypes.h>
	+#include <stdlib.h>
	+#include <stdio.h>
	+#include <string.h>
	+
	+#include "nbperf.h"
	+
	+#ifdef BUILD_CHM3
	+#include "graph3.h"
	+#else
	+#include "graph2.h"
	+#endif
	+
	+/*
	+ * A full description of the algorithm can be found in:
	+ * "An optimal algorithm for generating minimal perfect hash functions"
	+ * by Czech, Havas and Majewski in Information Processing Letters,
	+ * 43(5):256-264, October 1992.
	+ */
	+
	+/*
	+ * The algorithm is based on random, acyclic graphs.
	+ *
	+ * Each edge in the represents a key. The vertices are the reminder of
	+ * the hash function mod n. n = cm with c > 2, otherwise the propability
	+ * of finding an acyclic graph is very low (for 2-graphs). The constant
	+ * for 3-graphs is 1.24.
	+ *
	+ * After the hashing phase, the graph is checked for cycles.
	+ * A cycle-free graph is either empty or has a vertex of degree 1.
	+ * Removing the edge for this vertex doesn't change this property,
	+ * so applying this recursively reduces the size of the graph.
	+ * If the graph is empty at the end of the process, it was acyclic.
	+ *
	+ * The assignment step now sets g[i] := 0 and processes the edges
	+ * in reverse order of removal. That ensures that at least one vertex
	+ * is always unvisited and can be assigned.
	+ */
	+
	+struct state {
	+#ifdef BUILD_CHM3
	+ struct graph3 graph;
	+#else
	+ struct graph2 graph;
	+#endif
	+ uint32_t *g;
	+ uint8_t *visited;
	+};
	+
	+static void
	+assign_nodes(struct state *state)
	+{
	+#ifdef BUILD_CHM3
	+ struct edge3 *e;
	+#else
	+ struct edge2 *e;
	+#endif
	+ size_t i;
	+ uint32_t e_idx;
	+
	+ for (i = 0; i < state->graph.e; ++i) {
	+ e_idx = state->graph.output_order[i];
	+ e = &state->graph.edges[e_idx];
	+
	+#ifdef BUILD_CHM3
	+ if (!state->visited[e->left]) {
	+ state->g[e->left] = (2 * state->graph.e + e_idx
	+ - state->g[e->middle] - state->g[e->right])
	+ % state->graph.e;
	+ } else if (!state->visited[e->middle]) {
	+ state->g[e->middle] = (2 * state->graph.e + e_idx
	+ - state->g[e->left] - state->g[e->right])
	+ % state->graph.e;
	+ } else {
	+ state->g[e->right] = (2 * state->graph.e + e_idx
	+ - state->g[e->left] - state->g[e->middle])
	+ % state->graph.e;
	+ }
	+ state->visited[e->left] = 1;
	+ state->visited[e->middle] = 1;
	+ state->visited[e->right] = 1;
	+#else
	+ if (!state->visited[e->left]) {
	+ state->g[e->left] = (state->graph.e + e_idx
	+ - state->g[e->right]) % state->graph.e;
	+ } else {
	+ state->g[e->right] = (state->graph.e + e_idx
	+ - state->g[e->left]) % state->graph.e;
	+ }
	+ state->visited[e->left] = 1;
	+ state->visited[e->right] = 1;
	+#endif
	+ }
	+}
	+
	+static void
	+print_hash(struct nbperf nbperf, struct state state)
	+{
	+ uint32_t i, per_line;
	+ const char *g_type;
	+ int g_width;
	+
	+ fprintf(nbperf->output, "#include <stdlib.h>\n\n");
	+
	+ fprintf(nbperf->output, "%suint32_t\n",
	+ nbperf->static_hash ? "static " : "");
	+ fprintf(nbperf->output,
	+ "%s(const void * __restrict key, size_t keylen)\n",
	+ nbperf->hash_name);
	+ fprintf(nbperf->output, "{\n");
	+ if (state->graph.v >= 65536) {
	+ g_type = "uint32_t";
	+ g_width = 8;
	+ per_line = 4;
	+ } else if (state->graph.v >= 256) {
	+ g_type = "uint16_t";
	+ g_width = 4;
	+ per_line = 8;
	+ } else {
	+ g_type = "uint8_t";
	+ g_width = 2;
	+ per_line = 10;
	+ }
	+ fprintf(nbperf->output, "\tstatic const %s g[%" PRId32 "] = {\n",
	+ g_type, state->graph.v);
	+ for (i = 0; i < state->graph.v; ++i) {
	+ fprintf(nbperf->output, "%s0x%0*" PRIx32 ",%s",
	+ (i % per_line == 0 ? "\t " : " "),
	+ g_width, state->g[i],
	+ (i % per_line == per_line - 1 ? "\n" : ""));
	+ }
	+ if (i % per_line != 0)
	+ fprintf(nbperf->output, "\n\t};\n");
	+ else
	+ fprintf(nbperf->output, "\t};\n");
	+ fprintf(nbperf->output, "\tuint32_t h[%zu];\n\n", nbperf->hash_size);
	+ (*nbperf->print_hash)(nbperf, "\t", "key", "keylen", "h");
	+#ifdef BUILD_CHM3
	+ fprintf(nbperf->output, "\treturn (g[h[0] %% %" PRIu32 "] + "
	+ "g[h[1] %% %" PRIu32 "] + "
	+ "g[h[2] %% %" PRIu32"]) %% %" PRIu32 ";\n",
	+ state->graph.v, state->graph.v, state->graph.v, state->graph.e);
	+#else
	+ fprintf(nbperf->output, "\treturn (g[h[0] %% %" PRIu32 "] + "
	+ "g[h[1] %% %" PRIu32"]) %% %" PRIu32 ";\n",
	+ state->graph.v, state->graph.v, state->graph.e);
	+#endif
	+ fprintf(nbperf->output, "}\n");
	+
	+ if (nbperf->map_output != NULL) {
	+ for (i = 0; i < state->graph.e; ++i)
	+ fprintf(nbperf->map_output, "%" PRIu32 "\n", i);
	+ }
	+}
	+
	+int
	+#ifdef BUILD_CHM3
	+chm3_compute(struct nbperf *nbperf)
	+#else
	+chm_compute(struct nbperf *nbperf)
	+#endif
	+{
	+ struct state state;
	+ int retval = -1;
	+ uint32_t v, e;
	+
	+#ifdef BUILD_CHM3
	+ if (nbperf->c == 0)
	+ nbperf-> c = 1.24;
	+
	+ if (nbperf->c < 1.24)
	+ errx(1, "The argument for option -c must be at least 1.24");
	+
	+ if (nbperf->hash_size < 3)
	+ errx(1, "The hash function must generate at least 3 values");
	+#else
	+ if (nbperf->c == 0)
	+ nbperf-> c = 2;
	+
	+ if (nbperf->c < 2)
	+ errx(1, "The argument for option -c must be at least 2");
	+
	+ if (nbperf->hash_size < 2)
	+ errx(1, "The hash function must generate at least 2 values");
	+#endif
	+
	+ (*nbperf->seed_hash)(nbperf);
	+ e = nbperf->n;
	+ v = nbperf->c * nbperf->n;
	+#ifdef BUILD_CHM3
	+ if (v == 1.24 * nbperf->n)
	+ ++v;
	+ if (v < 10)
	+ v = 10;
	+#else
	+ if (v == 2 * nbperf->n)
	+ ++v;
	+#endif
	+
	+ state.g = calloc(sizeof(uint32_t), v);
	+ state.visited = calloc(sizeof(uint8_t), v);
	+ if (state.g == NULL \|\| state.visited == NULL)
	+ err(1, "malloc failed");
	+
	+#ifdef BUILD_CHM3
	+ graph3_setup(&state.graph, v, e);
	+ if (graph3_hash(nbperf, &state.graph))
	+ goto failed;
	+ if (graph3_output_order(&state.graph))
	+ goto failed;
	+#else
	+ graph2_setup(&state.graph, v, e);
	+ if (graph2_hash(nbperf, &state.graph))
	+ goto failed;
	+ if (graph2_output_order(&state.graph))
	+ goto failed;
	+#endif
	+ assign_nodes(&state);
	+ print_hash(nbperf, &state);
	+
	+ retval = 0;
	+
	+failed:
	+#ifdef BUILD_CHM3
	+ graph3_free(&state.graph);
	+#else
	+ graph2_free(&state.graph);
	+#endif
	+ free(state.g);
	+ free(state.visited);
	+ return retval;
	+}
	Index: contrib/mg/nbperf-chm3.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/nbperf-chm3.c
	@@ -0,0 +1,4 @@
	+/* $NetBSD: nbperf-chm3.c,v 1.1 2009/08/15 16:21:05 joerg Exp $ */
	+
	+#define BUILD_CHM3
	+#include "nbperf-chm.c"
	Index: contrib/mg/nbperf.h
	===================================================================
	--- /dev/null
	+++ contrib/mg/nbperf.h
	@@ -0,0 +1,61 @@
	+/* $NetBSD: nbperf.h,v 1.4 2013/01/31 16:32:02 joerg Exp $ */
	+/*-
	+ * Copyright (c) 2009 The NetBSD Foundation, Inc.
	+ * All rights reserved.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Joerg Sonnenberger.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ *
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in
	+ * the documentation and/or other materials provided with the
	+ * distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
	+ * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
	+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
	+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	+ * SUCH DAMAGE.
	+ */
	+
	+#define NBPERF_MAX_HASH_SIZE 3
	+
	+struct nbperf {
	+ FILE *output;
	+ FILE *map_output;
	+ const char *hash_name;
	+ int static_hash;
	+ size_t n;
	+ const void * __restrict * keys;
	+ const size_t *keylens;
	+ int first_round, has_duplicates;
	+
	+ double c;
	+
	+ size_t hash_size;
	+ void (seed_hash)(struct nbperf );
	+ void (print_hash)(struct nbperf , const char , const char , const char *,
	+ const char *);
	+ void (compute_hash)(struct nbperf , const void *, size_t,
	+ uint32_t *);
	+ uint32_t seed[1];
	+};
	+
	+int chm_compute(struct nbperf *);
	+int chm3_compute(struct nbperf *);
	+int bpz_compute(struct nbperf *);
	+void mi_vector_hash(const void * __restrict, size_t, uint32_t,
	+ uint32_t[3]);
	Index: contrib/mg/nbperf.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/nbperf.c
	@@ -0,0 +1,255 @@
	+/* $NetBSD: nbperf.c,v 1.5 2013/01/31 16:32:02 joerg Exp $ */
	+/*-
	+ * Copyright (c) 2009 The NetBSD Foundation, Inc.
	+ * All rights reserved.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Joerg Sonnenberger.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ *
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in
	+ * the documentation and/or other materials provided with the
	+ * distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
	+ * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
	+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
	+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
	+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	+ * SUCH DAMAGE.
	+ */
	+
	+#include <sys/cdefs.h>
	+#include <sys/endian.h>
	+
	+#include <err.h>
	+#include <errno.h>
	+#include <inttypes.h>
	+#include <stdlib.h>
	+#include <stdio.h>
	+#include <string.h>
	+#include <unistd.h>
	+
	+#include "nbperf.h"
	+
	+static int predictable;
	+
	+static __dead
	+void usage(void)
	+{
	+ fprintf(stderr,
	+ "%s [-ps] [-c utilisation] [-i iterations] [-n name] "
	+ "[-o output] input\n",
	+ getprogname());
	+ exit(1);
	+}
	+
	+#if HAVE_NBTOOL_CONFIG_H && !defined(__NetBSD__)
	+#define arc4random() rand()
	+#endif
	+
	+static void
	+mi_vector_hash_seed_hash(struct nbperf *nbperf)
	+{
	+ static uint32_t predictable_counter;
	+ if (predictable)
	+ nbperf->seed[0] = predictable_counter++;
	+ else
	+ nbperf->seed[0] = arc4random();
	+}
	+
	+static void
	+mi_vector_hash_compute(struct nbperf nbperf, const void key, size_t keylen,
	+ uint32_t *hashes)
	+{
	+ mi_vector_hash(key, keylen, nbperf->seed[0], hashes);
	+}
	+
	+static void
	+mi_vector_hash_print_hash(struct nbperf nbperf, const char indent,
	+ const char key, const char keylen, const char *hash)
	+{
	+ fprintf(nbperf->output,
	+ "%smi_vector_hash(%s, %s, 0x%08" PRIx32 "U, %s);\n",
	+ indent, key, keylen, nbperf->seed[0], hash);
	+}
	+
	+static void
	+set_hash(struct nbperf nbperf, const char arg)
	+{
	+ if (strcmp(arg, "mi_vector_hash") == 0) {
	+ nbperf->hash_size = 3;
	+ nbperf->seed_hash = mi_vector_hash_seed_hash;
	+ nbperf->compute_hash = mi_vector_hash_compute;
	+ nbperf->print_hash = mi_vector_hash_print_hash;
	+ return;
	+ }
	+ if (nbperf->hash_size > NBPERF_MAX_HASH_SIZE)
	+ errx(1, "Hash function creates too many output values");
	+ errx(1, "Unknown hash function: %s", arg);
	+}
	+
	+int
	+main(int argc, char **argv)
	+{
	+ struct nbperf nbperf = {
	+ .c = 0,
	+ .hash_name = "hash",
	+ .map_output = NULL,
	+ .output = NULL,
	+ .static_hash = 0,
	+ .first_round = 1,
	+ .has_duplicates = 0,
	+ };
	+ FILE *input;
	+ size_t curlen = 0, curalloc = 0;
	+ char line, eos;
	+ ssize_t line_len;
	+ size_t line_allocated;
	+ const void **keys = NULL;
	+ size_t *keylens = NULL;
	+ uint32_t max_iterations = 0xffffffU;
	+ long long tmp;
	+ int looped, ch;
	+ int (build_hash)(struct nbperf ) = chm_compute;
	+
	+ set_hash(&nbperf, "mi_vector_hash");
	+
	+ while ((ch = getopt(argc, argv, "a:c:h:i:m:n:o:ps")) != -1) {
	+ switch (ch) {
	+ case 'a':
	+ /* Accept bdz as alias for netbsd-6 compat. */
	+ if (strcmp(optarg, "chm") == 0)
	+ build_hash = chm_compute;
	+ else if (strcmp(optarg, "chm3") == 0)
	+ build_hash = chm3_compute;
	+ else if (strcmp(optarg, "bpz") == 0 \|\|
	+ strcmp(optarg, "bdz") == 0)
	+ build_hash = bpz_compute;
	+ else
	+ errx(1, "Unsupport algorithm: %s", optarg);
	+ break;
	+ case 'c':
	+ errno = 0;
	+ nbperf.c = strtod(optarg, &eos);
	+ if (errno \|\| eos[0] \|\| !nbperf.c)
	+ errx(2, "Invalid argument for -c");
	+ break;
	+ case 'h':
	+ set_hash(&nbperf, optarg);
	+ break;
	+ case 'i':
	+ errno = 0;
	+ tmp = strtoll(optarg, &eos, 0);
	+ if (errno \|\| eos == optarg \|\| eos[0] \|\|
	+ tmp < 0 \|\| tmp > 0xffffffffU)
	+ errx(2, "Iteration count must be "
	+ "a 32bit integer");
	+ max_iterations = (uint32_t)tmp;
	+ break;
	+ case 'm':
	+ if (nbperf.map_output)
	+ fclose(nbperf.map_output);
	+ nbperf.map_output = fopen(optarg, "w");
	+ if (nbperf.map_output == NULL)
	+ err(2, "cannot open map file");
	+ break;
	+ case 'n':
	+ nbperf.hash_name = optarg;
	+ break;
	+ case 'o':
	+ if (nbperf.output)
	+ fclose(nbperf.output);
	+ nbperf.output = fopen(optarg, "w");
	+ if (nbperf.output == NULL)
	+ err(2, "cannot open output file");
	+ break;
	+ case 'p':
	+ predictable = 1;
	+ break;
	+ case 's':
	+ nbperf.static_hash = 1;
	+ break;
	+ default:
	+ usage();
	+ }
	+ }
	+
	+ argc -= optind;
	+ argv += optind;
	+
	+ if (argc > 1)
	+ usage();
	+
	+ if (argc == 1) {
	+ input = fopen(argv[0], "r");
	+ if (input == NULL)
	+ err(1, "can't open input file");
	+ } else
	+ input = stdin;
	+
	+ if (nbperf.output == NULL)
	+ nbperf.output = stdout;
	+
	+ line = NULL;
	+ line_allocated = 0;
	+ while ((line_len = getline(&line, &line_allocated, input)) != -1) {
	+ if (line_len && line[line_len - 1] == '\n')
	+ --line_len;
	+ if (curlen == curalloc) {
	+ if (curalloc < 256)
	+ curalloc = 256;
	+ else
	+ curalloc += curalloc;
	+ keys = realloc(keys, curalloc * sizeof(*keys));
	+ if (keys == NULL)
	+ err(1, "realloc failed");
	+ keylens = realloc(keylens,
	+ curalloc * sizeof(*keylens));
	+ if (keylens == NULL)
	+ err(1, "realloc failed");
	+ }
	+ if ((keys[curlen] = strndup(line, line_len)) == NULL)
	+ err(1, "malloc failed");
	+ keylens[curlen] = line_len;
	+ ++curlen;
	+ }
	+ free(line);
	+
	+ if (input != stdin)
	+ fclose(input);
	+
	+ nbperf.n = curlen;
	+ nbperf.keys = keys;
	+ nbperf.keylens = keylens;
	+
	+ looped = 0;
	+ while ((*build_hash)(&nbperf)) {
	+ if (nbperf.has_duplicates)
	+ errx(1, "Duplicate keys detected");
	+ fputc('.', stderr);
	+ looped = 1;
	+ if (max_iterations == 0xffffffffU)
	+ continue;
	+ if (--max_iterations == 0) {
	+ fputc('\n', stderr);
	+ errx(1, "Iteration count reached");
	+ }
	+ }
	+ if (looped)
	+ fputc('\n', stderr);
	+
	+ return 0;
	+}
	Index: contrib/mg/paragraph.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/paragraph.c
	@@ -0,0 +1,499 @@
	+/* $OpenBSD: paragraph.c,v 1.46 2018/11/17 09:52:34 lum Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * Code for dealing with paragraphs and filling. Adapted from MicroEMACS 3.6
	+ * and GNU-ified by mwm@ucbvax. Several bug fixes by blarson@usc-oberon.
	+ */
	+
	+#include <sys/queue.h>
	+#include <ctype.h>
	+#include <limits.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+
	+#include "def.h"
	+
	+static int fillcol = 70;
	+
	+#define MAXWORD 256
	+
	+static int findpara(void);
	+static int do_gotoeop(int, int, int *);
	+
	+/*
	+ * Move to start of paragraph.
	+ * Move backwards by line, checking from the 1st character forwards for the
	+ * existence a non-space. If a non-space character is found, move to the
	+ * preceding line. Keep doing this until a line with only spaces is found or
	+ * the start of buffer.
	+ */
	+/* ARGSUSED */
	+int
	+gotobop(int f, int n)
	+{
	+ int col, nospace;
	+
	+ /* the other way... */
	+ if (n < 0)
	+ return (gotoeop(f, -n));
	+
	+ while (n-- > 0) {
	+ nospace = 0;
	+ while (lback(curwp->w_dotp) != curbp->b_headp) {
	+ curwp->w_doto = 0;
	+ col = 0;
	+
	+ while (col < llength(curwp->w_dotp) &&
	+ (isspace(lgetc(curwp->w_dotp, col))))
	+ col++;
	+
	+ if (col >= llength(curwp->w_dotp)) {
	+ if (nospace)
	+ break;
	+ } else
	+ nospace = 1;
	+
	+ curwp->w_dotline--;
	+ curwp->w_dotp = lback(curwp->w_dotp);
	+ }
	+ }
	+ /* force screen update */
	+ curwp->w_rflag \|= WFMOVE;
	+ return (TRUE);
	+}
	+
	+/*
	+ * Move to end of paragraph.
	+ * See comments for gotobop(). Same, but moving forwards.
	+ */
	+/* ARGSUSED */
	+int
	+gotoeop(int f, int n)
	+{
	+ int i;
	+
	+ return(do_gotoeop(f, n, &i));
	+}
	+
	+int
	+do_gotoeop(int f, int n, int *i)
	+{
	+ int col, nospace, j = 0;
	+
	+ /* the other way... */
	+ if (n < 0)
	+ return (gotobop(f, -n));
	+
	+ /* for each one asked for */
	+ while (n-- > 0) {
	+ *i = ++j;
	+ nospace = 0;
	+ while (lforw(curwp->w_dotp) != curbp->b_headp) {
	+ col = 0;
	+ curwp->w_doto = 0;
	+
	+ while (col < llength(curwp->w_dotp) &&
	+ (isspace(lgetc(curwp->w_dotp, col))))
	+ col++;
	+
	+ if (col >= llength(curwp->w_dotp)) {
	+ if (nospace)
	+ break;
	+ } else
	+ nospace = 1;
	+
	+ curwp->w_dotp = lforw(curwp->w_dotp);
	+ curwp->w_dotline++;
	+
	+ }
	+ }
	+ /* do not continue after end of buffer */
	+ if (lforw(curwp->w_dotp) == curbp->b_headp) {
	+ gotoeol(FFRAND, 1);
	+ curwp->w_rflag \|= WFMOVE;
	+ return (FALSE);
	+ }
	+
	+ /* force screen update */
	+ curwp->w_rflag \|= WFMOVE;
	+ return (TRUE);
	+}
	+
	+/*
	+ * Justify a paragraph. Fill the current paragraph according to the current
	+ * fill column.
	+ */
	+/* ARGSUSED */
	+int
	+fillpara(int f, int n)
	+{
	+ int c; /* current char during scan */
	+ int wordlen; /* length of current word */
	+ int clength; /* position on line during fill */
	+ int i; /* index during word copy */
	+ int eopflag; /* Are we at the End-Of-Paragraph? */
	+ int firstflag; /* first word? (needs no space) */
	+ int newlength; /* tentative new line length */
	+ int eolflag; /* was at end of line */
	+ int retval; /* return value */
	+ struct line eopline; / pointer to line just past EOP */
	+ char wbuf[MAXWORD]; /* buffer for current word */
	+
	+ if (n == 0)
	+ return (TRUE);
	+
	+ undo_boundary_enable(FFRAND, 0);
	+
	+ /* record the pointer to the line just past the EOP */
	+ (void)gotoeop(FFRAND, 1);
	+ if (curwp->w_doto != 0) {
	+ /* paragraph ends at end of buffer */
	+ (void)lnewline();
	+ eopline = lforw(curwp->w_dotp);
	+ } else
	+ eopline = curwp->w_dotp;
	+
	+ /* and back top the beginning of the paragraph */
	+ (void)gotobop(FFRAND, 1);
	+
	+ /* initialize various info */
	+ while (inword() == 0 && forwchar(FFRAND, 1));
	+
	+ clength = curwp->w_doto;
	+ wordlen = 0;
	+
	+ /* scan through lines, filling words */
	+ firstflag = TRUE;
	+ eopflag = FALSE;
	+ while (!eopflag) {
	+
	+ /* get the next character in the paragraph */
	+ if ((eolflag = (curwp->w_doto == llength(curwp->w_dotp)))) {
	+ c = ' ';
	+ if (lforw(curwp->w_dotp) == eopline)
	+ eopflag = TRUE;
	+ } else
	+ c = lgetc(curwp->w_dotp, curwp->w_doto);
	+
	+ /* and then delete it */
	+ if (ldelete((RSIZE) 1, KNONE) == FALSE && !eopflag) {
	+ retval = FALSE;
	+ goto cleanup;
	+ }
	+
	+ /* if not a separator, just add it in */
	+ if (c != ' ' && c != '\t') {
	+ if (wordlen < MAXWORD - 1)
	+ wbuf[wordlen++] = c;
	+ else {
	+ /*
	+ * You lose chars beyond MAXWORD if the word
	+ * is too long. I'm too lazy to fix it now; it
	+ * just silently truncated the word before,
	+ * so I get to feel smug.
	+ */
	+ ewprintf("Word too long!");
	+ }
	+ } else if (wordlen) {
	+
	+ /* calculate tentative new length with word added */
	+ newlength = clength + 1 + wordlen;
	+
	+ /*
	+ * if at end of line or at doublespace and previous
	+ * character was one of '.','?','!' doublespace here.
	+ * behave the same way if a ')' is preceded by a
	+ * [.?!] and followed by a doublespace.
	+ */
	+ if (dblspace && (!eopflag && ((eolflag \|\|
	+ curwp->w_doto == llength(curwp->w_dotp) \|\|
	+ (c = lgetc(curwp->w_dotp, curwp->w_doto)) == ' '
	+ \|\| c == '\t') && (ISEOSP(wbuf[wordlen - 1]) \|\|
	+ (wbuf[wordlen - 1] == ')' && wordlen >= 2 &&
	+ ISEOSP(wbuf[wordlen - 2])))) &&
	+ wordlen < MAXWORD - 1))
	+ wbuf[wordlen++] = ' ';
	+
	+ /* at a word break with a word waiting */
	+ if (newlength <= fillcol) {
	+ /* add word to current line */
	+ if (!firstflag) {
	+ (void)linsert(1, ' ');
	+ ++clength;
	+ }
	+ firstflag = FALSE;
	+ } else {
	+ if (curwp->w_doto > 0 &&
	+ lgetc(curwp->w_dotp, curwp->w_doto - 1) == ' ') {
	+ curwp->w_doto -= 1;
	+ (void)ldelete((RSIZE) 1, KNONE);
	+ }
	+ /* start a new line */
	+ (void)lnewline();
	+ clength = 0;
	+ }
	+
	+ /* and add the word in in either case */
	+ for (i = 0; i < wordlen; i++) {
	+ (void)linsert(1, wbuf[i]);
	+ ++clength;
	+ }
	+ wordlen = 0;
	+ }
	+ }
	+ /* and add a last newline for the end of our new paragraph */
	+ (void)lnewline();
	+
	+ /*
	+ * We really should wind up where we started, (which is hard to keep
	+ * track of) but I think the end of the last line is better than the
	+ * beginning of the blank line.
	+ */
	+ (void)backchar(FFRAND, 1);
	+ retval = TRUE;
	+cleanup:
	+ undo_boundary_enable(FFRAND, 1);
	+ return (retval);
	+}
	+
	+/*
	+ * Delete n paragraphs. Move to the beginning of the current paragraph, or if
	+ * the cursor is on an empty line, move down the buffer to the first line with
	+ * non-space characters. Then mark n paragraphs and delete.
	+ */
	+/* ARGSUSED */
	+int
	+killpara(int f, int n)
	+{
	+ int lineno, status;
	+
	+ if (n == 0)
	+ return (TRUE);
	+
	+ if (findpara() == FALSE)
	+ return (TRUE);
	+
	+ /* go to the beginning of the paragraph */
	+ (void)gotobop(FFRAND, 1);
	+
	+ /* take a note of the line number for after deletions and set mark */
	+ lineno = curwp->w_dotline;
	+ curwp->w_markp = curwp->w_dotp;
	+ curwp->w_marko = curwp->w_doto;
	+
	+ (void)gotoeop(FFRAND, n);
	+
	+ if ((status = killregion(FFRAND, 1)) != TRUE)
	+ return (status);
	+
	+ curwp->w_dotline = lineno;
	+ return (TRUE);
	+}
	+
	+/*
	+ * Mark n paragraphs starting with the n'th and working our way backwards.
	+ * This leaves the cursor at the beginning of the paragraph where markpara()
	+ * was invoked.
	+ */
	+/* ARGSUSED */
	+int
	+markpara(int f, int n)
	+{
	+ int i = 0;
	+
	+ if (n == 0)
	+ return (TRUE);
	+
	+ clearmark(FFARG, 0);
	+
	+ if (findpara() == FALSE)
	+ return (TRUE);
	+
	+ (void)do_gotoeop(FFRAND, n, &i);
	+
	+ /* set the mark here */
	+ curwp->w_markp = curwp->w_dotp;
	+ curwp->w_marko = curwp->w_doto;
	+
	+ (void)gotobop(FFRAND, i);
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * Transpose the current paragraph with the following paragraph. If invoked
	+ * multiple times, transpose to the n'th paragraph. If invoked between
	+ * paragraphs, move to the previous paragraph, then continue.
	+ */
	+/* ARGSUSED */
	+int
	+transposepara(int f, int n)
	+{
	+ int i = 0, status;
	+ char flg;
	+
	+ if (n == 0)
	+ return (TRUE);
	+
	+ undo_boundary_enable(FFRAND, 0);
	+
	+ /* find a paragraph, set mark, then goto the end */
	+ gotobop(FFRAND, 1);
	+ curwp->w_markp = curwp->w_dotp;
	+ curwp->w_marko = curwp->w_doto;
	+ (void)gotoeop(FFRAND, 1);
	+
	+ /* take a note of buffer flags - we may need them */
	+ flg = curbp->b_flag;
	+
	+ /* clean out kill buffer then kill region */
	+ kdelete();
	+ if ((status = killregion(FFRAND, 1)) != TRUE)
	+ return (status);
	+
	+ /*
	+ * Now step through n paragraphs. If we reach the end of buffer,
	+ * stop and paste the killed region back, then display a message.
	+ */
	+ if (do_gotoeop(FFRAND, n, &i) == FALSE) {
	+ ewprintf("Cannot transpose paragraph, end of buffer reached.");
	+ (void)gotobop(FFRAND, i);
	+ (void)yank(FFRAND, 1);
	+ curbp->b_flag = flg;
	+ return (FALSE);
	+ }
	+ (void)yank(FFRAND, 1);
	+
	+ undo_boundary_enable(FFRAND, 1);
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * Go down the buffer until we find a line with non-space characters.
	+ */
	+int
	+findpara(void)
	+{
	+ int col, nospace = 0;
	+
	+ /* we move forward to find a para to mark */
	+ do {
	+ curwp->w_doto = 0;
	+ col = 0;
	+
	+ /* check if we are on a blank line */
	+ while (col < llength(curwp->w_dotp)) {
	+ if (!isspace(lgetc(curwp->w_dotp, col)))
	+ nospace = 1;
	+ col++;
	+ }
	+ if (nospace)
	+ break;
	+
	+ if (lforw(curwp->w_dotp) == curbp->b_headp)
	+ return (FALSE);
	+
	+ curwp->w_dotp = lforw(curwp->w_dotp);
	+ curwp->w_dotline++;
	+ } while (1);
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * Insert char with work wrap. Check to see if we're past fillcol, and if so,
	+ * justify this line. As a last step, justify the line.
	+ */
	+/* ARGSUSED */
	+int
	+fillword(int f, int n)
	+{
	+ char c;
	+ int col, i, nce;
	+
	+ for (i = col = 0; col <= fillcol; ++i, ++col) {
	+ if (i == curwp->w_doto)
	+ return selfinsert(f, n);
	+ c = lgetc(curwp->w_dotp, i);
	+ if (c == '\t'
	+#ifdef NOTAB
	+ && !(curbp->b_flag & BFNOTAB)
	+#endif
	+ )
	+ col \|= 0x07;
	+ else if (ISCTRL(c) != FALSE)
	+ ++col;
	+ }
	+ if (curwp->w_doto != llength(curwp->w_dotp)) {
	+ (void)selfinsert(f, n);
	+ nce = llength(curwp->w_dotp) - curwp->w_doto;
	+ } else
	+ nce = 0;
	+ curwp->w_doto = i;
	+
	+ if ((c = lgetc(curwp->w_dotp, curwp->w_doto)) != ' ' && c != '\t')
	+ do {
	+ (void)backchar(FFRAND, 1);
	+ } while ((c = lgetc(curwp->w_dotp, curwp->w_doto)) != ' ' &&
	+ c != '\t' && curwp->w_doto > 0);
	+
	+ if (curwp->w_doto == 0)
	+ do {
	+ (void)forwchar(FFRAND, 1);
	+ } while ((c = lgetc(curwp->w_dotp, curwp->w_doto)) != ' ' &&
	+ c != '\t' && curwp->w_doto < llength(curwp->w_dotp));
	+
	+ (void)delwhite(FFRAND, 1);
	+ (void)lnewline();
	+ i = llength(curwp->w_dotp) - nce;
	+ curwp->w_doto = i > 0 ? i : 0;
	+ curwp->w_rflag \|= WFMOVE;
	+ if (nce == 0 && curwp->w_doto != 0)
	+ return (fillword(f, n));
	+ return (TRUE);
	+}
	+
	+/*
	+ * Set fill column to n for justify.
	+ */
	+int
	+setfillcol(int f, int n)
	+{
	+ char buf[32], *rep;
	+ const char *es;
	+ int nfill;
	+
	+ if ((f & FFARG) != 0) {
	+ fillcol = n;
	+ } else {
	+ if ((rep = eread("Set fill-column: ", buf, sizeof(buf),
	+ EFNEW \| EFCR)) == NULL)
	+ return (ABORT);
	+ else if (rep[0] == '\0')
	+ return (FALSE);
	+ nfill = strtonum(rep, 0, INT_MAX, &es);
	+ if (es != NULL) {
	+ dobeep();
	+ ewprintf("Invalid fill column: %s", rep);
	+ return (FALSE);
	+ }
	+ fillcol = nfill;
	+ ewprintf("Fill column set to %d", fillcol);
	+ }
	+ return (TRUE);
	+}
	+
	+int
	+sentencespace(int f, int n)
	+{
	+ if (f & FFARG)
	+ dblspace = n > 1;
	+ else
	+ dblspace = !dblspace;
	+
	+ return (TRUE);
	+}
	Index: contrib/mg/pathnames.h
	===================================================================
	--- /dev/null
	+++ contrib/mg/pathnames.h
	@@ -0,0 +1,11 @@
	+/* $OpenBSD: pathnames.h,v 1.1 2012/06/18 07:14:55 jasper Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * standard path names
	+ */
	+
	+#define _PATH_MG_DIR "~/.mg.d"
	+#define _PATH_MG_STARTUP "%s/.mg"
	+#define _PATH_MG_TERM "%s/.mg-%s"
	Index: contrib/mg/re_search.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/re_search.c
	@@ -0,0 +1,665 @@
	+/* $OpenBSD: re_search.c,v 1.36 2021/04/22 19:50:55 lum Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * regular expression search commands for Mg
	+ *
	+ * This file contains functions to implement several of gnuemacs's regular
	+ * expression functions for Mg. Several of the routines below are just minor
	+ * re-arrangements of Mg's non-regular expression search functions. Some of
	+ * them are similar in structure to the original MicroEMACS, others are
	+ * modifications of Rich Ellison's code. Peter Newton re-wrote about half of
	+ * them from scratch.
	+ */
	+
	+#ifdef REGEX
	+#include <sys/queue.h>
	+#include <sys/types.h>
	+#include <regex.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <string.h>
	+
	+#include "def.h"
	+#include "macro.h"
	+
	+#define SRCH_BEGIN (0) /* search sub-codes */
	+#define SRCH_FORW (-1)
	+#define SRCH_BACK (-2)
	+#define SRCH_NOPR (-3)
	+#define SRCH_ACCM (-4)
	+#define SRCH_MARK (-5)
	+
	+#define RE_NMATCH 10 /* max number of matches */
	+#define REPLEN 256 /* max length of replacement string */
	+
	+char re_pat[NPAT]; /* regex pattern */
	+int re_srch_lastdir = SRCH_NOPR; /* last search flags */
	+int casefoldsearch = TRUE; /* does search ignore case? */
	+
	+static int re_doreplace(RSIZE, char *);
	+static int re_forwsrch(void);
	+static int re_backsrch(void);
	+static int re_readpattern(char *);
	+static int killmatches(int);
	+static int countmatches(int);
	+
	+/*
	+ * Search forward.
	+ * Get a search string from the user and search for it starting at ".". If
	+ * found, move "." to just after the matched characters. display does all
	+ * the hard stuff. If not found, it just prints a message.
	+ */
	+/* ARGSUSED */
	+int
	+re_forwsearch(int f, int n)
	+{
	+ int s;
	+
	+ if ((s = re_readpattern("RE Search")) != TRUE)
	+ return (s);
	+ if (re_forwsrch() == FALSE) {
	+ dobeep();
	+ ewprintf("Search failed: \"%s\"", re_pat);
	+ return (FALSE);
	+ }
	+ re_srch_lastdir = SRCH_FORW;
	+ return (TRUE);
	+}
	+
	+/*
	+ * Reverse search.
	+ * Get a search string from the user, and search, starting at "."
	+ * and proceeding toward the front of the buffer. If found "." is left
	+ * pointing at the first character of the pattern [the last character that
	+ * was matched].
	+ */
	+/* ARGSUSED */
	+int
	+re_backsearch(int f, int n)
	+{
	+ int s;
	+
	+ if ((s = re_readpattern("RE Search backward")) != TRUE)
	+ return (s);
	+ if (re_backsrch() == FALSE) {
	+ dobeep();
	+ ewprintf("Search failed: \"%s\"", re_pat);
	+ return (FALSE);
	+ }
	+ re_srch_lastdir = SRCH_BACK;
	+ return (TRUE);
	+}
	+
	+/*
	+ * Search again, using the same search string and direction as the last search
	+ * command. The direction has been saved in "srch_lastdir", so you know which
	+ * way to go.
	+ *
	+ * XXX: This code has problems -- some incompatibility(?) with extend.c causes
	+ * match to fail when it should not.
	+ */
	+/* ARGSUSED */
	+int
	+re_searchagain(int f, int n)
	+{
	+ if (re_srch_lastdir == SRCH_NOPR) {
	+ dobeep();
	+ ewprintf("No last search");
	+ return (FALSE);
	+ }
	+ if (re_srch_lastdir == SRCH_FORW) {
	+ if (re_forwsrch() == FALSE) {
	+ dobeep();
	+ ewprintf("Search failed: \"%s\"", re_pat);
	+ return (FALSE);
	+ }
	+ return (TRUE);
	+ }
	+ if (re_srch_lastdir == SRCH_BACK)
	+ if (re_backsrch() == FALSE) {
	+ dobeep();
	+ ewprintf("Search failed: \"%s\"", re_pat);
	+ return (FALSE);
	+ }
	+
	+ return (TRUE);
	+}
	+
	+/* Compiled regex goes here-- changed only when new pattern read */
	+static regex_t regex_buff;
	+static regmatch_t regex_match[RE_NMATCH];
	+
	+/*
	+ * Re-Query Replace.
	+ * Replace strings selectively. Does a search and replace operation.
	+ */
	+/* ARGSUSED */
	+int
	+re_queryrepl(int f, int n)
	+{
	+ int rcnt = 0; /* replacements made so far */
	+ int plen, s; /* length of found string */
	+ char news[NPAT]; /* replacement string */
	+
	+ if ((s = re_readpattern("RE Query replace")) != TRUE)
	+ return (s);
	+ if (eread("Query replace %s with: ", news, NPAT,
	+ EFNUL \| EFNEW \| EFCR, re_pat) == NULL)
	+ return (ABORT);
	+ ewprintf("Query replacing %s with %s:", re_pat, news);
	+
	+ /*
	+ * Search forward repeatedly, checking each time whether to insert
	+ * or not. The "!" case makes the check always true, so it gets put
	+ * into a tighter loop for efficiency.
	+ */
	+ while (re_forwsrch() == TRUE) {
	+retry:
	+ update(CMODE);
	+ switch (getkey(FALSE)) {
	+ case ' ':
	+ plen = regex_match[0].rm_eo - regex_match[0].rm_so;
	+ if (re_doreplace((RSIZE)plen, news) == FALSE)
	+ return (FALSE);
	+ rcnt++;
	+ break;
	+
	+ case '.':
	+ plen = regex_match[0].rm_eo - regex_match[0].rm_so;
	+ if (re_doreplace((RSIZE)plen, news) == FALSE)
	+ return (FALSE);
	+ rcnt++;
	+ goto stopsearch;
	+
	+ case CCHR('G'): /* ^G */
	+ (void)ctrlg(FFRAND, 0);
	+ goto stopsearch;
	+ case CCHR('['): /* ESC */
	+ case '`':
	+ goto stopsearch;
	+ case '!':
	+ do {
	+ plen = regex_match[0].rm_eo - regex_match[0].rm_so;
	+ if (re_doreplace((RSIZE)plen, news) == FALSE)
	+ return (FALSE);
	+ rcnt++;
	+ } while (re_forwsrch() == TRUE);
	+ goto stopsearch;
	+
	+ case CCHR('?'): /* To not replace */
	+ break;
	+
	+ default:
	+ ewprintf("<SP> replace, [.] rep-end, <DEL> don't, [!] repl rest <ESC> quit");
	+ goto retry;
	+ }
	+ }
	+
	+stopsearch:
	+ curwp->w_rflag \|= WFFULL;
	+ update(CMODE);
	+ if (!inmacro) {
	+ if (rcnt == 0)
	+ ewprintf("(No replacements done)");
	+ else if (rcnt == 1)
	+ ewprintf("(1 replacement done)");
	+ else
	+ ewprintf("(%d replacements done)", rcnt);
	+ }
	+ return (TRUE);
	+}
	+
	+int
	+re_repl(int f, int n)
	+{
	+ int rcnt = 0; /* replacements made so far */
	+ int plen, s; /* length of found string */
	+ char news[NPAT]; /* replacement string */
	+
	+ if ((s = re_readpattern("RE Replace")) != TRUE)
	+ return (s);
	+ if (eread("Replace %s with: ", news, NPAT,
	+ EFNUL \| EFNEW \| EFCR, re_pat) == NULL)
	+ return (ABORT);
	+
	+ while (re_forwsrch() == TRUE) {
	+ plen = regex_match[0].rm_eo - regex_match[0].rm_so;
	+ if (re_doreplace((RSIZE)plen, news) == FALSE)
	+ return (FALSE);
	+ rcnt++;
	+ }
	+
	+ curwp->w_rflag \|= WFFULL;
	+ update(CMODE);
	+ if (!inmacro)
	+ ewprintf("(%d replacement(s) done)", rcnt);
	+
	+ return(TRUE);
	+}
	+
	+/*
	+ * Routine re_doreplace calls lreplace to make replacements needed by
	+ * re_query replace. Its reason for existence is to deal with \1, \2. etc.
	+ * plen: length to remove
	+ * st: replacement string
	+ */
	+static int
	+re_doreplace(RSIZE plen, char *st)
	+{
	+ int j, k, s, more, num, state;
	+ struct line *clp;
	+ char repstr[REPLEN];
	+
	+ clp = curwp->w_dotp;
	+ more = TRUE;
	+ j = 0;
	+ state = 0;
	+ num = 0;
	+
	+ /* The following FSA parses the replacement string */
	+ while (more) {
	+ switch (state) {
	+ case 0:
	+ if (*st == '\\') {
	+ st++;
	+ state = 1;
	+ } else if (*st == '\0')
	+ more = FALSE;
	+ else {
	+ repstr[j] = *st;
	+ j++;
	+ if (j >= REPLEN)
	+ return (FALSE);
	+ st++;
	+ }
	+ break;
	+ case 1:
	+ if (st >= '0' && st <= '9') {
	+ num = *st - '0';
	+ st++;
	+ state = 2;
	+ } else if (*st == '\0')
	+ more = FALSE;
	+ else {
	+ repstr[j] = *st;
	+ j++;
	+ if (j >= REPLEN)
	+ return (FALSE);
	+ st++;
	+ state = 0;
	+ }
	+ break;
	+ case 2:
	+ if (st >= '0' && st <= '9') {
	+ num = 10 * num + *st - '0';
	+ st++;
	+ } else {
	+ if (num >= RE_NMATCH)
	+ return (FALSE);
	+ k = regex_match[num].rm_eo - regex_match[num].rm_so;
	+ if (j + k >= REPLEN)
	+ return (FALSE);
	+ bcopy(&(clp->l_text[regex_match[num].rm_so]),
	+ &repstr[j], k);
	+ j += k;
	+ if (*st == '\0')
	+ more = FALSE;
	+ if (*st == '\\') {
	+ st++;
	+ state = 1;
	+ } else {
	+ repstr[j] = *st;
	+ j++;
	+ if (j >= REPLEN)
	+ return (FALSE);
	+ st++;
	+ state = 0;
	+ }
	+ }
	+ break;
	+ } /* switch (state) */
	+ } /* while (more) */
	+
	+ repstr[j] = '\0';
	+ s = lreplace(plen, repstr);
	+ return (s);
	+}
	+
	+/*
	+ * This routine does the real work of a forward search. The pattern is
	+ * sitting in the external variable "pat". If found, dot is updated, the
	+ * window system is notified of the change, and TRUE is returned. If the
	+ * string isn't found, FALSE is returned.
	+ */
	+static int
	+re_forwsrch(void)
	+{
	+ int re_flags, tbo, tdotline, error;
	+ struct line *clp;
	+
	+ clp = curwp->w_dotp;
	+ tbo = curwp->w_doto;
	+ tdotline = curwp->w_dotline;
	+
	+ if (tbo == clp->l_used)
	+ /*
	+ * Don't start matching past end of line -- must move to
	+ * beginning of next line, unless line is empty or at
	+ * end of file.
	+ */
	+ if (clp != curbp->b_headp && llength(clp) != 0) {
	+ clp = lforw(clp);
	+ tdotline++;
	+ tbo = 0;
	+ }
	+ /*
	+ * Note this loop does not process the last line, but this editor
	+ * always makes the last line empty so this is good.
	+ */
	+ while (clp != (curbp->b_headp)) {
	+ re_flags = REG_STARTEND;
	+ if (tbo != 0)
	+ re_flags \|= REG_NOTBOL;
	+ regex_match[0].rm_so = tbo;
	+ regex_match[0].rm_eo = llength(clp);
	+ error = regexec(&regex_buff, ltext(clp) ? ltext(clp) : "",
	+ RE_NMATCH, regex_match, re_flags);
	+ if (error != 0) {
	+ clp = lforw(clp);
	+ tdotline++;
	+ tbo = 0;
	+ } else {
	+ curwp->w_doto = regex_match[0].rm_eo;
	+ curwp->w_dotp = clp;
	+ curwp->w_dotline = tdotline;
	+ curwp->w_rflag \|= WFMOVE;
	+ return (TRUE);
	+ }
	+ }
	+ return (FALSE);
	+}
	+
	+/*
	+ * This routine does the real work of a backward search. The pattern is sitting
	+ * in the external variable "re_pat". If found, dot is updated, the window
	+ * system is notified of the change, and TRUE is returned. If the string isn't
	+ * found, FALSE is returned.
	+ */
	+static int
	+re_backsrch(void)
	+{
	+ struct line *clp;
	+ int tbo, tdotline;
	+ regmatch_t lastmatch;
	+
	+ clp = curwp->w_dotp;
	+ tbo = curwp->w_doto;
	+ tdotline = curwp->w_dotline;
	+
	+ /* Start search one position to the left of dot */
	+ tbo = tbo - 1;
	+ if (tbo < 0) {
	+ /* must move up one line */
	+ clp = lback(clp);
	+ tdotline--;
	+ tbo = llength(clp);
	+ }
	+
	+ /*
	+ * Note this loop does not process the last line, but this editor
	+ * always makes the last line empty so this is good.
	+ */
	+ while (clp != (curbp->b_headp)) {
	+ regex_match[0].rm_so = 0;
	+ regex_match[0].rm_eo = llength(clp);
	+ lastmatch.rm_so = -1;
	+ /*
	+ * Keep searching until we don't match any longer. Assumes a
	+ * non-match does not modify the regex_match array. We have to
	+ * do this character-by-character after the first match since
	+ * POSIX regexps don't give you a way to do reverse matches.
	+ */
	+ while (!regexec(&regex_buff, ltext(clp) ? ltext(clp) : "",
	+ RE_NMATCH, regex_match, REG_STARTEND) &&
	+ regex_match[0].rm_so <= tbo) {
	+ memcpy(&lastmatch, &regex_match[0], sizeof(regmatch_t));
	+ regex_match[0].rm_so++;
	+ regex_match[0].rm_eo = llength(clp);
	+ }
	+ if (lastmatch.rm_so == -1) {
	+ clp = lback(clp);
	+ tdotline--;
	+ tbo = llength(clp);
	+ } else {
	+ memcpy(&regex_match[0], &lastmatch, sizeof(regmatch_t));
	+ curwp->w_doto = regex_match[0].rm_so;
	+ curwp->w_dotp = clp;
	+ curwp->w_dotline = tdotline;
	+ curwp->w_rflag \|= WFMOVE;
	+ return (TRUE);
	+ }
	+ }
	+ return (FALSE);
	+}
	+
	+/*
	+ * Read a pattern.
	+ * Stash it in the external variable "re_pat". The "pat" is
	+ * not updated if the user types in an empty line. If the user typed
	+ * an empty line, and there is no old pattern, it is an error.
	+ * Display the old pattern, in the style of Jeff Lomicka. There is
	+ * some do-it-yourself control expansion.
	+ */
	+static int
	+re_readpattern(char *re_prompt)
	+{
	+ static int dofree = 0;
	+ int flags, error, s;
	+ char tpat[NPAT], *rep;
	+
	+ if (re_pat[0] == '\0')
	+ rep = eread("%s: ", tpat, NPAT, EFNEW \| EFCR, re_prompt);
	+ else
	+ rep = eread("%s (default %s): ", tpat, NPAT,
	+ EFNUL \| EFNEW \| EFCR, re_prompt, re_pat);
	+ if (rep == NULL)
	+ return (ABORT);
	+ if (rep[0] != '\0') {
	+ /* New pattern given */
	+ (void)strlcpy(re_pat, tpat, sizeof(re_pat));
	+ if (casefoldsearch)
	+ flags = REG_EXTENDED \| REG_ICASE;
	+ else
	+ flags = REG_EXTENDED;
	+ if (dofree)
	+ regfree(&regex_buff);
	+ error = regcomp(&regex_buff, re_pat, flags);
	+ if (error != 0) {
	+ char message[256];
	+ regerror(error, &regex_buff, message, sizeof(message));
	+ dobeep();
	+ ewprintf("Regex Error: %s", message);
	+ re_pat[0] = '\0';
	+ return (FALSE);
	+ }
	+ dofree = 1;
	+ s = TRUE;
	+ } else if (rep[0] == '\0' && re_pat[0] != '\0')
	+ /* Just using old pattern */
	+ s = TRUE;
	+ else
	+ s = FALSE;
	+ return (s);
	+}
	+
	+/*
	+ * Cause case to not matter in searches. This is the default. If called
	+ * with argument cause case to matter.
	+ */
	+/* ARGSUSED*/
	+int
	+setcasefold(int f, int n)
	+{
	+ if (f & FFARG) {
	+ casefoldsearch = FALSE;
	+ ewprintf("Case-fold-search unset");
	+ } else {
	+ casefoldsearch = TRUE;
	+ ewprintf("Case-fold-search set");
	+ }
	+
	+ /*
	+ * Invalidate the regular expression pattern since I'm too lazy to
	+ * recompile it.
	+ */
	+ re_pat[0] = '\0';
	+ return (TRUE);
	+}
	+
	+/*
	+ * Delete all lines after dot that contain a string matching regex.
	+ */
	+/* ARGSUSED */
	+int
	+delmatchlines(int f, int n)
	+{
	+ int s;
	+
	+ if ((s = re_readpattern("Flush lines (containing match for regexp)"))
	+ != TRUE)
	+ return (s);
	+
	+ s = killmatches(TRUE);
	+ return (s);
	+}
	+
	+/*
	+ * Delete all lines after dot that don't contain a string matching regex.
	+ */
	+/* ARGSUSED */
	+int
	+delnonmatchlines(int f, int n)
	+{
	+ int s;
	+
	+ if ((s = re_readpattern("Keep lines (containing match for regexp)"))
	+ != TRUE)
	+ return (s);
	+
	+ s = killmatches(FALSE);
	+ return (s);
	+}
	+
	+/*
	+ * This function does the work of deleting matching lines.
	+ */
	+static int
	+killmatches(int cond)
	+{
	+ int s, error;
	+ int count = 0;
	+ struct line *clp;
	+
	+ clp = curwp->w_dotp;
	+ if (curwp->w_doto == llength(clp))
	+ /* Consider dot on next line */
	+ clp = lforw(clp);
	+
	+ while (clp != (curbp->b_headp)) {
	+ /* see if line matches */
	+ regex_match[0].rm_so = 0;
	+ regex_match[0].rm_eo = llength(clp);
	+ error = regexec(&regex_buff, ltext(clp) ? ltext(clp) : "",
	+ RE_NMATCH, regex_match, REG_STARTEND);
	+
	+ /* Delete line when appropriate */
	+ if ((cond == FALSE && error) \|\| (cond == TRUE && !error)) {
	+ curwp->w_doto = 0;
	+ curwp->w_dotp = clp;
	+ count++;
	+ s = ldelete(llength(clp) + 1, KNONE);
	+ clp = curwp->w_dotp;
	+ curwp->w_rflag \|= WFMOVE;
	+ if (s == FALSE)
	+ return (FALSE);
	+ } else
	+ clp = lforw(clp);
	+ }
	+
	+ ewprintf("%d line(s) deleted", count);
	+ if (count > 0)
	+ curwp->w_rflag \|= WFMOVE;
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * Count lines matching regex.
	+ */
	+/* ARGSUSED */
	+int
	+cntmatchlines(int f, int n)
	+{
	+ int s;
	+
	+ if ((s = re_readpattern("Count lines (matching regexp)")) != TRUE)
	+ return (s);
	+ s = countmatches(TRUE);
	+
	+ return (s);
	+}
	+
	+/*
	+ * Count lines that fail to match regex.
	+ */
	+/* ARGSUSED */
	+int
	+cntnonmatchlines(int f, int n)
	+{
	+ int s;
	+
	+ if ((s = re_readpattern("Count lines (not matching regexp)")) != TRUE)
	+ return (s);
	+ s = countmatches(FALSE);
	+
	+ return (s);
	+}
	+
	+/*
	+ * This function does the work of counting matching lines.
	+ */
	+int
	+countmatches(int cond)
	+{
	+ int error;
	+ int count = 0;
	+ struct line *clp;
	+
	+ clp = curwp->w_dotp;
	+ if (curwp->w_doto == llength(clp))
	+ /* Consider dot on next line */
	+ clp = lforw(clp);
	+
	+ while (clp != (curbp->b_headp)) {
	+ /* see if line matches */
	+ regex_match[0].rm_so = 0;
	+ regex_match[0].rm_eo = llength(clp);
	+ error = regexec(&regex_buff, ltext(clp) ? ltext(clp) : "",
	+ RE_NMATCH, regex_match, REG_STARTEND);
	+
	+ /* Count line when appropriate */
	+ if ((cond == FALSE && error) \|\| (cond == TRUE && !error))
	+ count++;
	+ clp = lforw(clp);
	+ }
	+
	+ if (cond)
	+ ewprintf("Number of lines matching: %d", count);
	+ else
	+ ewprintf("Number of lines not matching: %d", count);
	+
	+ return (TRUE);
	+}
	+#endif /* REGEX */
	Index: contrib/mg/reallocarray.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/reallocarray.c
	@@ -0,0 +1,44 @@
	+/* $OpenBSD: reallocarray.c,v 1.2 2014/12/08 03:45:00 bcook Exp $ */
	+/*
	+ * Copyright (c) 2008 Otto Moerbeek <otto@drijf.net>
	+ *
	+ * Permission to use, copy, modify, and distribute this software for any
	+ * purpose with or without fee is hereby granted, provided that the above
	+ * copyright notice and this permission notice appear in all copies.
	+ *
	+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	+ */
	+
	+#include <sys/types.h>
	+#include <errno.h>
	+#include <stdint.h>
	+#include <stdlib.h>
	+
	+#include "config.h"
	+
	+#ifndef HAVE_REALLOCARRAY
	+
	+/*
	+ * This is sqrt(SIZE_MAX+1), as s1*s2 <= SIZE_MAX
	+ * if both s1 < MUL_NO_OVERFLOW and s2 < MUL_NO_OVERFLOW
	+ */
	+#define MUL_NO_OVERFLOW ((size_t)1 << (sizeof(size_t) * 4))
	+
	+void *
	+reallocarray(void *optr, size_t nmemb, size_t size)
	+{
	+ if ((nmemb >= MUL_NO_OVERFLOW \|\| size >= MUL_NO_OVERFLOW) &&
	+ nmemb > 0 && SIZE_MAX / nmemb < size) {
	+ errno = ENOMEM;
	+ return NULL;
	+ }
	+ return realloc(optr, size * nmemb);
	+}
	+
	+#endif /* !HAVE_REALLOCARRAY */
	Index: contrib/mg/region.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/region.c
	@@ -0,0 +1,682 @@
	+/* $OpenBSD: region.c,v 1.39 2021/03/01 10:51:14 lum Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * Region based commands.
	+ * The routines in this file deal with the region, that magic space between
	+ * "." and mark. Some functions are commands. Some functions are just for
	+ * internal use.
	+ */
	+
	+#include <sys/queue.h>
	+#include <sys/socket.h>
	+#include <sys/types.h>
	+#include <sys/wait.h>
	+#include <errno.h>
	+#include <fcntl.h>
	+#include <poll.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+#include <unistd.h>
	+
	+#include "def.h"
	+
	+#define TIMEOUT 10000
	+
	+static char leftover[BUFSIZ];
	+
	+static int getregion(struct region *);
	+static int iomux(int, char * const, int, struct buffer *);
	+static int preadin(int, struct buffer *);
	+static void pwriteout(int, char *, int );
	+static int setsize(struct region *, RSIZE);
	+static int shellcmdoutput(char * const[], char * const, int);
	+
	+/*
	+ * Kill the region. Ask "getregion" to figure out the bounds of the region.
	+ * Move "." to the start, and kill the characters. Mark is cleared afterwards.
	+ */
	+/* ARGSUSED */
	+int
	+killregion(int f, int n)
	+{
	+ int s;
	+ struct region region;
	+
	+ if ((s = getregion(&region)) != TRUE)
	+ return (s);
	+ /* This is a kill-type command, so do magic kill buffer stuff. */
	+ if ((lastflag & CFKILL) == 0)
	+ kdelete();
	+ thisflag \|= CFKILL;
	+ curwp->w_dotp = region.r_linep;
	+ curwp->w_doto = region.r_offset;
	+ curwp->w_dotline = region.r_lineno;
	+ s = ldelete(region.r_size, KFORW \| KREG);
	+ clearmark(FFARG, 0);
	+
	+ return (s);
	+}
	+
	+/*
	+ * Copy all of the characters in the region to the kill buffer,
	+ * clearing the mark afterwards.
	+ * This is a bit like a kill region followed by a yank.
	+ */
	+/* ARGSUSED */
	+int
	+copyregion(int f, int n)
	+{
	+ struct line *linep;
	+ struct region region;
	+ int loffs;
	+ int s;
	+
	+ if ((s = getregion(&region)) != TRUE)
	+ return (s);
	+
	+ /* kill type command */
	+ if ((lastflag & CFKILL) == 0)
	+ kdelete();
	+ thisflag \|= CFKILL;
	+
	+ /* current line */
	+ linep = region.r_linep;
	+
	+ /* current offset */
	+ loffs = region.r_offset;
	+
	+ while (region.r_size--) {
	+ if (loffs == llength(linep)) { /* End of line. */
	+ if ((s = kinsert(*curbp->b_nlchr, KFORW)) != TRUE)
	+ return (s);
	+ linep = lforw(linep);
	+ loffs = 0;
	+ } else { /* Middle of line. */
	+ if ((s = kinsert(lgetc(linep, loffs), KFORW)) != TRUE)
	+ return (s);
	+ ++loffs;
	+ }
	+ }
	+ clearmark(FFARG, 0);
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * Lower case region. Zap all of the upper case characters in the region to
	+ * lower case. Use the region code to set the limits. Scan the buffer, doing
	+ * the changes. Call "lchange" to ensure that redisplay is done in all
	+ * buffers.
	+ */
	+/* ARGSUSED */
	+int
	+lowerregion(int f, int n)
	+{
	+ struct line *linep;
	+ struct region region;
	+ int loffs, c, s;
	+
	+ if ((s = checkdirty(curbp)) != TRUE)
	+ return (s);
	+ if (curbp->b_flag & BFREADONLY) {
	+ dobeep();
	+ ewprintf("Buffer is read-only");
	+ return (FALSE);
	+ }
	+
	+ if ((s = getregion(&region)) != TRUE)
	+ return (s);
	+
	+ undo_add_change(region.r_linep, region.r_offset, region.r_size);
	+
	+ lchange(WFFULL);
	+ linep = region.r_linep;
	+ loffs = region.r_offset;
	+ while (region.r_size--) {
	+ if (loffs == llength(linep)) {
	+ linep = lforw(linep);
	+ loffs = 0;
	+ } else {
	+ c = lgetc(linep, loffs);
	+ if (ISUPPER(c) != FALSE)
	+ lputc(linep, loffs, TOLOWER(c));
	+ ++loffs;
	+ }
	+ }
	+ return (TRUE);
	+}
	+
	+/*
	+ * Upper case region. Zap all of the lower case characters in the region to
	+ * upper case. Use the region code to set the limits. Scan the buffer,
	+ * doing the changes. Call "lchange" to ensure that redisplay is done in all
	+ * buffers.
	+ */
	+/* ARGSUSED */
	+int
	+upperregion(int f, int n)
	+{
	+ struct line *linep;
	+ struct region region;
	+ int loffs, c, s;
	+
	+ if ((s = checkdirty(curbp)) != TRUE)
	+ return (s);
	+ if (curbp->b_flag & BFREADONLY) {
	+ dobeep();
	+ ewprintf("Buffer is read-only");
	+ return (FALSE);
	+ }
	+ if ((s = getregion(&region)) != TRUE)
	+ return (s);
	+
	+ undo_add_change(region.r_linep, region.r_offset, region.r_size);
	+
	+ lchange(WFFULL);
	+ linep = region.r_linep;
	+ loffs = region.r_offset;
	+ while (region.r_size--) {
	+ if (loffs == llength(linep)) {
	+ linep = lforw(linep);
	+ loffs = 0;
	+ } else {
	+ c = lgetc(linep, loffs);
	+ if (ISLOWER(c) != FALSE)
	+ lputc(linep, loffs, TOUPPER(c));
	+ ++loffs;
	+ }
	+ }
	+ return (TRUE);
	+}
	+
	+/*
	+ * This routine figures out the bound of the region in the current window,
	+ * and stores the results into the fields of the REGION structure. Dot and
	+ * mark are usually close together, but I don't know the order, so I scan
	+ * outward from dot, in both directions, looking for mark. The size is kept
	+ * in a long. At the end, after the size is figured out, it is assigned to
	+ * the size field of the region structure. If this assignment loses any bits,
	+ * then we print an error. This is "type independent" overflow checking. All
	+ * of the callers of this routine should be ready to get an ABORT status,
	+ * because I might add a "if regions is big, ask before clobbering" flag.
	+ */
	+static int
	+getregion(struct region *rp)
	+{
	+ struct line flp, blp;
	+ long fsize, bsize;
	+
	+ if (curwp->w_markp == NULL) {
	+ dobeep();
	+ ewprintf("No mark set in this window");
	+ return (FALSE);
	+ }
	+
	+ /* "r_size" always ok */
	+ if (curwp->w_dotp == curwp->w_markp) {
	+ rp->r_linep = curwp->w_dotp;
	+ rp->r_lineno = curwp->w_dotline;
	+ if (curwp->w_doto < curwp->w_marko) {
	+ rp->r_offset = curwp->w_doto;
	+ rp->r_size = (RSIZE)(curwp->w_marko - curwp->w_doto);
	+ } else {
	+ rp->r_offset = curwp->w_marko;
	+ rp->r_size = (RSIZE)(curwp->w_doto - curwp->w_marko);
	+ }
	+ return (TRUE);
	+ }
	+ /* get region size */
	+ flp = blp = curwp->w_dotp;
	+ bsize = curwp->w_doto;
	+ fsize = llength(flp) - curwp->w_doto + 1;
	+ while (lforw(flp) != curbp->b_headp \|\| lback(blp) != curbp->b_headp) {
	+ if (lforw(flp) != curbp->b_headp) {
	+ flp = lforw(flp);
	+ if (flp == curwp->w_markp) {
	+ rp->r_linep = curwp->w_dotp;
	+ rp->r_offset = curwp->w_doto;
	+ rp->r_lineno = curwp->w_dotline;
	+ return (setsize(rp,
	+ (RSIZE)(fsize + curwp->w_marko)));
	+ }
	+ fsize += llength(flp) + 1;
	+ }
	+ if (lback(blp) != curbp->b_headp) {
	+ blp = lback(blp);
	+ bsize += llength(blp) + 1;
	+ if (blp == curwp->w_markp) {
	+ rp->r_linep = blp;
	+ rp->r_offset = curwp->w_marko;
	+ rp->r_lineno = curwp->w_markline;
	+ return (setsize(rp,
	+ (RSIZE)(bsize - curwp->w_marko)));
	+ }
	+ }
	+ }
	+ dobeep();
	+ ewprintf("Bug: lost mark");
	+ return (FALSE);
	+}
	+
	+/*
	+ * Set size, and check for overflow.
	+ */
	+static int
	+setsize(struct region *rp, RSIZE size)
	+{
	+ rp->r_size = size;
	+ if (rp->r_size != size) {
	+ dobeep();
	+ ewprintf("Region is too large");
	+ return (FALSE);
	+ }
	+ return (TRUE);
	+}
	+
	+#define PREFIXLENGTH 40
	+static char prefix_string[PREFIXLENGTH] = {'>', '\0'};
	+
	+/*
	+ * Prefix the region with whatever is in prefix_string. Leaves dot at the
	+ * beginning of the line after the end of the region. If an argument is
	+ * given, prompts for the line prefix string.
	+ */
	+/* ARGSUSED */
	+int
	+prefixregion(int f, int n)
	+{
	+ struct line first, last;
	+ struct region region;
	+ char *prefix = prefix_string;
	+ int nline;
	+ int s;
	+
	+ if ((s = checkdirty(curbp)) != TRUE)
	+ return (s);
	+ if (curbp->b_flag & BFREADONLY) {
	+ dobeep();
	+ ewprintf("Buffer is read-only");
	+ return (FALSE);
	+ }
	+ if ((f == TRUE) && ((s = setprefix(FFRAND, 1)) != TRUE))
	+ return (s);
	+
	+ /* get # of lines to affect */
	+ if ((s = getregion(&region)) != TRUE)
	+ return (s);
	+ first = region.r_linep;
	+ last = (first == curwp->w_dotp) ? curwp->w_markp : curwp->w_dotp;
	+ for (nline = 1; first != last; nline++)
	+ first = lforw(first);
	+
	+ /* move to beginning of region */
	+ curwp->w_dotp = region.r_linep;
	+ curwp->w_doto = region.r_offset;
	+ curwp->w_dotline = region.r_lineno;
	+
	+ /* for each line, go to beginning and insert the prefix string */
	+ while (nline--) {
	+ (void)gotobol(FFRAND, 1);
	+ for (prefix = prefix_string; *prefix; prefix++)
	+ (void)linsert(1, *prefix);
	+ (void)forwline(FFRAND, 1);
	+ }
	+ (void)gotobol(FFRAND, 1);
	+ return (TRUE);
	+}
	+
	+/*
	+ * Set line prefix string. Used by prefixregion.
	+ */
	+/* ARGSUSED */
	+int
	+setprefix(int f, int n)
	+{
	+ char buf[PREFIXLENGTH], *rep;
	+ int retval;
	+
	+ if (prefix_string[0] == '\0')
	+ rep = eread("Prefix string: ", buf, sizeof(buf),
	+ EFNEW \| EFCR);
	+ else
	+ rep = eread("Prefix string (default %s): ", buf, sizeof(buf),
	+ EFNUL \| EFNEW \| EFCR, prefix_string);
	+ if (rep == NULL)
	+ return (ABORT);
	+ if (rep[0] != '\0') {
	+ (void)strlcpy(prefix_string, rep, sizeof(prefix_string));
	+ retval = TRUE;
	+ } else if (rep[0] == '\0' && prefix_string[0] != '\0') {
	+ /* CR -- use old one */
	+ retval = TRUE;
	+ } else
	+ retval = FALSE;
	+ return (retval);
	+}
	+
	+int
	+region_get_data(struct region reg, char buf, int len)
	+{
	+ int i, off;
	+ struct line *lp;
	+
	+ off = reg->r_offset;
	+ lp = reg->r_linep;
	+ for (i = 0; i < len; i++) {
	+ if (off == llength(lp)) {
	+ lp = lforw(lp);
	+ if (lp == curbp->b_headp)
	+ break;
	+ off = 0;
	+ buf[i] = *curbp->b_nlchr;
	+ } else {
	+ buf[i] = lgetc(lp, off);
	+ off++;
	+ }
	+ }
	+ buf[i] = '\0';
	+ return (i);
	+}
	+
	+void
	+region_put_data(const char *buf, int len)
	+{
	+ int i;
	+
	+ for (i = 0; buf[i] != '\0' && i < len; i++) {
	+ if (buf[i] == *curbp->b_nlchr)
	+ lnewline();
	+ else
	+ linsert(1, buf[i]);
	+ }
	+}
	+
	+/*
	+ * Mark whole buffer by first traversing to end-of-buffer
	+ * and then to beginning-of-buffer. Mark, dot are implicitly
	+ * set to eob, bob respectively during traversal.
	+ */
	+int
	+markbuffer(int f, int n)
	+{
	+ if (gotoeob(f,n) == FALSE)
	+ return (FALSE);
	+ (void) clearmark(f, n);
	+ if (gotobob(f,n) == FALSE)
	+ return (FALSE);
	+ return (TRUE);
	+}
	+
	+/*
	+ * Pipe text from current region to external command.
	+ */
	+/ARGSUSED /
	+int
	+piperegion(int f, int n)
	+{
	+ struct region region;
	+ int len;
	+ char cmd, cmdbuf[NFILEN], text;
	+ char argv[] = {"sh", "-c", (char ) NULL, (char *) NULL};
	+
	+ /* C-u M-\| is not supported yet */
	+ if (n > 1)
	+ return (ABORT);
	+
	+ if (curwp->w_markp == NULL) {
	+ dobeep();
	+ ewprintf("The mark is not set now, so there is no region");
	+ return (FALSE);
	+ }
	+
	+ if ((cmd = eread("Shell command on region: ", cmdbuf, sizeof(cmdbuf),
	+ EFNEW \| EFCR)) == NULL \|\| (cmd[0] == '\0'))
	+ return (ABORT);
	+
	+ argv[2] = cmd;
	+
	+ if (getregion(&region) != TRUE)
	+ return (FALSE);
	+
	+ len = region.r_size;
	+
	+ if ((text = malloc(len + 1)) == NULL) {
	+ dobeep();
	+ ewprintf("Cannot allocate memory.");
	+ return (FALSE);
	+ }
	+
	+ region_get_data(&region, text, len);
	+
	+ return shellcmdoutput(argv, text, len);
	+}
	+
	+/*
	+ * Get command from mini-buffer and execute externally.
	+ */
	+/ARGSUSED /
	+int
	+shellcommand(int f, int n)
	+{
	+
	+ char *cmd, cmdbuf[NFILEN];
	+ char argv[] = {"sh", "-c", (char ) NULL, (char *) NULL};
	+
	+ if (n > 1)
	+ return (ABORT);
	+
	+ if ((cmd = eread("Shell command: ", cmdbuf, sizeof(cmdbuf),
	+ EFNEW \| EFCR)) == NULL \|\| (cmd[0] == '\0'))
	+ return (ABORT);
	+
	+ argv[2] = cmd;
	+
	+ return shellcmdoutput(argv, NULL, 0);
	+}
	+
	+
	+int
	+shellcmdoutput(char* const argv[], char* const text, int len)
	+{
	+
	+ struct buffer *bp;
	+ char *shellp;
	+ int ret;
	+
	+ bp = bfind("Shell Command Output", TRUE);
	+ bp->b_flag \|= BFREADONLY;
	+ if (bclear(bp) != TRUE) {
	+ free(text);
	+ return (FALSE);
	+ }
	+
	+ shellp = getenv("SHELL");
	+
	+ ret = pipeio(shellp, argv, text, len, bp);
	+
	+ if (ret == TRUE) {
	+ eerase();
	+ if (lforw(bp->b_headp) == bp->b_headp)
	+ addline(bp, "(Shell command succeeded with no output)");
	+ }
	+
	+ free(text);
	+ return (ret);
	+}
	+
	+/*
	+ * Create a socketpair, fork and execv path with argv.
	+ * STDIN, STDOUT and STDERR of child process are redirected to socket.
	+ * Parent writes len chars from text to socket.
	+ */
	+int
	+pipeio(const char* const path, char* const argv[], char* const text, int len,
	+ struct buffer *outbp)
	+{
	+ int s[2], ret;
	+ char *err;
	+ pid_t pid;
	+
	+ if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, s) == -1) {
	+ dobeep();
	+ ewprintf("socketpair error");
	+ return (FALSE);
	+ }
	+
	+ switch((pid = fork())) {
	+ case -1:
	+ dobeep();
	+ ewprintf("Can't fork");
	+ return (FALSE);
	+ case 0:
	+ /* Child process */
	+ close(s[0]);
	+ if (dup2(s[1], STDIN_FILENO) == -1)
	+ _exit(1);
	+ if (dup2(s[1], STDOUT_FILENO) == -1)
	+ _exit(1);
	+ if (dup2(s[1], STDERR_FILENO) == -1)
	+ _exit(1);
	+ if (path == NULL)
	+ _exit(1);
	+
	+ execv(path, argv);
	+ err = strerror(errno);
	+ write(s[1], err, strlen(err));
	+ _exit(1);
	+ default:
	+ /* Parent process */
	+ close(s[1]);
	+ ret = iomux(s[0], text, len, outbp);
	+ waitpid(pid, NULL, 0); /* Collect child to prevent zombies */
	+
	+ return (ret);
	+ }
	+ return (FALSE);
	+}
	+
	+/*
	+ * Multiplex read, write on socket fd passed. Put output in outbp
	+ * Poll on the fd for both read and write readiness.
	+ */
	+int
	+iomux(int fd, char* const text, int len, struct buffer *outbp)
	+{
	+ struct pollfd pfd[1];
	+ int nfds;
	+ char *textcopy;
	+
	+ textcopy = text;
	+ fcntl(fd, F_SETFL, O_NONBLOCK);
	+ pfd[0].fd = fd;
	+
	+ /* There is nothing to write if len is zero
	+ * but the cmd's output should be read so shutdown
	+ * the socket for writing only and don't wait for POLLOUT
	+ */
	+ if (len == 0) {
	+ shutdown(fd, SHUT_WR);
	+ pfd[0].events = POLLIN;
	+ } else
	+ pfd[0].events = POLLIN \| POLLOUT;
	+
	+ while ((nfds = poll(pfd, 1, TIMEOUT)) != -1 \|\|
	+ (pfd[0].revents & (POLLERR \| POLLHUP \| POLLNVAL))) {
	+ if (pfd[0].revents & POLLOUT && len > 0)
	+ pwriteout(fd, &textcopy, &len);
	+ else if (pfd[0].revents & POLLIN)
	+ if (preadin(fd, outbp) == FALSE)
	+ break;
	+ if (len == 0 && pfd[0].events & POLLOUT)
	+ pfd[0].events = POLLIN;
	+ }
	+ close(fd);
	+
	+ /* In case if last line doesn't have a '\n' add the leftover
	+ * characters to buffer.
	+ */
	+ if (leftover[0] != '\0') {
	+ addline(outbp, leftover);
	+ leftover[0] = '\0';
	+ }
	+ if (nfds == 0) {
	+ dobeep();
	+ ewprintf("poll timed out");
	+ return (FALSE);
	+ } else if (nfds == -1) {
	+ dobeep();
	+ ewprintf("poll error");
	+ return (FALSE);
	+ }
	+ return (popbuftop(outbp, WNONE));
	+}
	+
	+/*
	+ * Write some text from region to fd. Once done shutdown the
	+ * write end.
	+ */
	+void
	+pwriteout(int fd, char *text, int len)
	+{
	+ int w;
	+
	+ if (((w = send(fd, text, len, MSG_NOSIGNAL)) == -1)) {
	+ switch(errno) {
	+ case EPIPE:
	+ *len = -1;
	+ break;
	+ case EAGAIN:
	+ return;
	+ }
	+ } else
	+ *len -= w;
	+
	+ *text += w;
	+ if (*len <= 0)
	+ shutdown(fd, SHUT_WR);
	+}
	+
	+/*
	+ * Read some data from socket fd, break on '\n' and add
	+ * to buffer. If couldn't break on newline hold leftover
	+ * characters and append in next iteration.
	+ */
	+int
	+preadin(int fd, struct buffer *bp)
	+{
	+ int len;
	+ char buf[BUFSIZ], p, q;
	+
	+ if ((len = read(fd, buf, BUFSIZ - 1)) <= 0)
	+ return (FALSE);
	+
	+ buf[len] = '\0';
	+ p = q = buf;
	+ if (leftover[0] != '\0' && ((q = strchr(p, *bp->b_nlchr)) != NULL)) {
	+ *q++ = '\0';
	+ if (strlcat(leftover, p, sizeof(leftover)) >=
	+ sizeof(leftover)) {
	+ dobeep();
	+ ewprintf("line too long");
	+ return (FALSE);
	+ }
	+ addline(bp, leftover);
	+ leftover[0] = '\0';
	+ p = q;
	+ }
	+ while ((q = strchr(p, *bp->b_nlchr)) != NULL) {
	+ *q++ = '\0';
	+ addline(bp, p);
	+ p = q;
	+ }
	+ if (strlcpy(leftover, p, sizeof(leftover)) >= sizeof(leftover)) {
	+ dobeep();
	+ ewprintf("line too long");
	+ return (FALSE);
	+ }
	+ return (TRUE);
	+}
	Index: contrib/mg/search.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/search.c
	@@ -0,0 +1,855 @@
	+/* $OpenBSD: search.c,v 1.47 2018/07/11 12:21:37 krw Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * Search commands.
	+ * The functions in this file implement the search commands (both plain and
	+ * incremental searches are supported) and the query-replace command.
	+ *
	+ * The plain old search code is part of the original MicroEMACS "distribution".
	+ * The incremental search code and the query-replace code is by Rich Ellison.
	+ */
	+
	+#include <sys/queue.h>
	+#include <ctype.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <string.h>
	+
	+#include "def.h"
	+#include "macro.h"
	+
	+#define SRCH_BEGIN (0) /* Search sub-codes. */
	+#define SRCH_FORW (-1)
	+#define SRCH_BACK (-2)
	+#define SRCH_NOPR (-3)
	+#define SRCH_ACCM (-4)
	+#define SRCH_MARK (-5)
	+
	+struct srchcom {
	+ int s_code;
	+ struct line *s_dotp;
	+ int s_doto;
	+ int s_dotline;
	+};
	+
	+static int isearch(int);
	+static void is_cpush(int);
	+static void is_lpush(void);
	+static void is_pop(void);
	+static int is_peek(void);
	+static void is_undo(int , int );
	+static int is_find(int);
	+static void is_prompt(int, int, int);
	+static void is_dspl(char *, int);
	+static int eq(int, int, int);
	+
	+static struct srchcom cmds[NSRCH];
	+static int cip;
	+
	+int srch_lastdir = SRCH_NOPR; /* Last search flags. */
	+
	+/*
	+ * Search forward. Get a search string from the user, and search for it
	+ * starting at ".". If found, "." gets moved to just after the matched
	+ * characters, and display does all the hard stuff. If not found, it just
	+ * prints a message.
	+ */
	+/* ARGSUSED */
	+int
	+forwsearch(int f, int n)
	+{
	+ int s;
	+
	+ if ((s = readpattern("Search")) != TRUE)
	+ return (s);
	+ if (forwsrch() == FALSE) {
	+ dobeep();
	+ ewprintf("Search failed: \"%s\"", pat);
	+ return (FALSE);
	+ }
	+ srch_lastdir = SRCH_FORW;
	+ return (TRUE);
	+}
	+
	+/*
	+ * Reverse search. Get a search string from the user, and search, starting
	+ * at "." and proceeding toward the front of the buffer. If found "." is
	+ * left pointing at the first character of the pattern [the last character
	+ * that was matched].
	+ */
	+/* ARGSUSED */
	+int
	+backsearch(int f, int n)
	+{
	+ int s;
	+
	+ if ((s = readpattern("Search backward")) != TRUE)
	+ return (s);
	+ if (backsrch() == FALSE) {
	+ dobeep();
	+ ewprintf("Search failed: \"%s\"", pat);
	+ return (FALSE);
	+ }
	+ srch_lastdir = SRCH_BACK;
	+ return (TRUE);
	+}
	+
	+/*
	+ * Search again, using the same search string and direction as the last
	+ * search command. The direction has been saved in "srch_lastdir", so you
	+ * know which way to go.
	+ */
	+/* ARGSUSED */
	+int
	+searchagain(int f, int n)
	+{
	+ if (srch_lastdir == SRCH_FORW) {
	+ if (forwsrch() == FALSE) {
	+ dobeep();
	+ ewprintf("Search failed: \"%s\"", pat);
	+ return (FALSE);
	+ }
	+ return (TRUE);
	+ }
	+ if (srch_lastdir == SRCH_BACK) {
	+ if (backsrch() == FALSE) {
	+ dobeep();
	+ ewprintf("Search failed: \"%s\"", pat);
	+ return (FALSE);
	+ }
	+ return (TRUE);
	+ }
	+ dobeep();
	+ ewprintf("No last search");
	+ return (FALSE);
	+}
	+
	+/*
	+ * Use incremental searching, initially in the forward direction.
	+ * isearch ignores any explicit arguments.
	+ */
	+/* ARGSUSED */
	+int
	+forwisearch(int f, int n)
	+{
	+ if (macrodef \|\| inmacro)
	+ /* We can't isearch in macro. Use search instead */
	+ return (forwsearch(f,n));
	+ else
	+ return (isearch(SRCH_FORW));
	+}
	+
	+/*
	+ * Use incremental searching, initially in the reverse direction.
	+ * isearch ignores any explicit arguments.
	+ */
	+/* ARGSUSED */
	+int
	+backisearch(int f, int n)
	+{
	+ if (macrodef \|\| inmacro)
	+ /* We can't isearch in macro. Use search instead */
	+ return (backsearch(f,n));
	+ else
	+ return (isearch(SRCH_BACK));
	+}
	+
	+/*
	+ * Incremental Search.
	+ * dir is used as the initial direction to search.
	+ * ^M exit from Isearch, set mark
	+ * ^S switch direction to forward
	+ * ^R switch direction to reverse
	+ * ^Q quote next character (allows searching for ^N etc.)
	+ * <ESC> exit from Isearch, set mark
	+ * <DEL> undoes last character typed. (tricky job to do this correctly).
	+ * other ^ exit search, don't set mark
	+ * else accumulate into search string
	+ */
	+static int
	+isearch(int dir)
	+{
	+ struct line clp; / Saved line pointer */
	+ int c;
	+ int cbo; /* Saved offset */
	+ int success;
	+ int pptr;
	+ int firstc;
	+ int xcase;
	+ int i;
	+ char opat[NPAT];
	+ int cdotline; /* Saved line number */
	+
	+ if (macrodef) {
	+ dobeep();
	+ ewprintf("Can't isearch in macro");
	+ return (FALSE);
	+ }
	+ for (cip = 0; cip < NSRCH; cip++)
	+ cmds[cip].s_code = SRCH_NOPR;
	+
	+ (void)strlcpy(opat, pat, sizeof(opat));
	+ cip = 0;
	+ pptr = -1;
	+ clp = curwp->w_dotp;
	+ cbo = curwp->w_doto;
	+ cdotline = curwp->w_dotline;
	+ is_lpush();
	+ is_cpush(SRCH_BEGIN);
	+ success = TRUE;
	+ is_prompt(dir, TRUE, success);
	+
	+ for (;;) {
	+ update(CMODE);
	+
	+ switch (c = getkey(FALSE)) {
	+ case CCHR('['):
	+ /*
	+ * If new characters come in the next 300 msec,
	+ * we can assume that they belong to a longer
	+ * escaped sequence so we should ungetkey the
	+ * ESC to avoid writing out garbage.
	+ */
	+ if (ttwait(300) == FALSE)
	+ ungetkey(c);
	+ /* FALLTHRU */
	+ case CCHR('M'):
	+ srch_lastdir = dir;
	+ curwp->w_markp = clp;
	+ curwp->w_marko = cbo;
	+ curwp->w_markline = cdotline;
	+ ewprintf("Mark set");
	+ return (TRUE);
	+ case CCHR('G'):
	+ if (success != TRUE) {
	+ while (is_peek() == SRCH_ACCM)
	+ is_undo(&pptr, &dir);
	+ success = TRUE;
	+ is_prompt(dir, pptr < 0, success);
	+ break;
	+ }
	+ curwp->w_dotp = clp;
	+ curwp->w_doto = cbo;
	+ curwp->w_dotline = cdotline;
	+ curwp->w_rflag \|= WFMOVE;
	+ srch_lastdir = dir;
	+ (void)ctrlg(FFRAND, 0);
	+ (void)strlcpy(pat, opat, sizeof(pat));
	+ return (ABORT);
	+ case CCHR('S'):
	+ if (dir == SRCH_BACK) {
	+ dir = SRCH_FORW;
	+ is_lpush();
	+ is_cpush(SRCH_FORW);
	+ success = TRUE;
	+ }
	+ if (success == FALSE && dir == SRCH_FORW) {
	+ /* wrap the search to beginning */
	+ curwp->w_dotp = bfirstlp(curbp);
	+ curwp->w_doto = 0;
	+ curwp->w_dotline = 1;
	+ if (is_find(dir) != FALSE) {
	+ is_cpush(SRCH_MARK);
	+ success = TRUE;
	+ }
	+ ewprintf("Overwrapped I-search: %s", pat);
	+ break;
	+ }
	+ is_lpush();
	+ pptr = strlen(pat);
	+ if (forwchar(FFRAND, 1) == FALSE) {
	+ dobeep();
	+ success = FALSE;
	+ ewprintf("Failed I-search: %s", pat);
	+ } else {
	+ if (is_find(SRCH_FORW) != FALSE)
	+ is_cpush(SRCH_MARK);
	+ else {
	+ (void)backchar(FFRAND, 1);
	+ dobeep();
	+ success = FALSE;
	+ ewprintf("Failed I-search: %s", pat);
	+ }
	+ }
	+ is_prompt(dir, pptr < 0, success);
	+ break;
	+ case CCHR('R'):
	+ if (dir == SRCH_FORW) {
	+ dir = SRCH_BACK;
	+ is_lpush();
	+ is_cpush(SRCH_BACK);
	+ success = TRUE;
	+ }
	+ if (success == FALSE && dir == SRCH_BACK) {
	+ /* wrap the search to end */
	+ curwp->w_dotp = blastlp(curbp);
	+ curwp->w_doto = llength(curwp->w_dotp);
	+ curwp->w_dotline = curwp->w_bufp->b_lines;
	+ if (is_find(dir) != FALSE) {
	+ is_cpush(SRCH_MARK);
	+ success = TRUE;
	+ }
	+ ewprintf("Overwrapped I-search: %s", pat);
	+ break;
	+ }
	+ is_lpush();
	+ pptr = strlen(pat);
	+ if (backchar(FFRAND, 1) == FALSE) {
	+ dobeep();
	+ success = FALSE;
	+ } else {
	+ if (is_find(SRCH_BACK) != FALSE)
	+ is_cpush(SRCH_MARK);
	+ else {
	+ (void)forwchar(FFRAND, 1);
	+ dobeep();
	+ success = FALSE;
	+ }
	+ }
	+ is_prompt(dir, pptr < 0, success);
	+ break;
	+ case CCHR('W'):
	+ /* add the rest of the current word to the pattern */
	+ clp = curwp->w_dotp;
	+ cbo = curwp->w_doto;
	+ firstc = 1;
	+ if (pptr == -1)
	+ pptr = 0;
	+ if (dir == SRCH_BACK) {
	+ /* when isearching backwards, cbo is the start of the pattern */
	+ cbo += pptr;
	+ }
	+
	+ /* if the search is case insensitive, add to pattern using lowercase */
	+ xcase = 0;
	+ for (i = 0; pat[i]; i++)
	+ if (ISUPPER(CHARMASK(pat[i])))
	+ xcase = 1;
	+
	+ while (cbo < llength(clp)) {
	+ c = lgetc(clp, cbo++);
	+ if ((!firstc && !isalnum(c)))
	+ break;
	+
	+ if (pptr == NPAT - 1) {
	+ dobeep();
	+ break;
	+ }
	+ firstc = 0;
	+ if (!xcase && ISUPPER(c))
	+ c = TOLOWER(c);
	+
	+ pat[pptr++] = c;
	+ pat[pptr] = '\0';
	+ /* cursor only moves when isearching forwards */
	+ if (dir == SRCH_FORW) {
	+ curwp->w_doto = cbo;
	+ curwp->w_rflag \|= WFMOVE;
	+ update(CMODE);
	+ }
	+ }
	+ is_prompt(dir, pptr < 0, success);
	+ break;
	+ case CCHR('H'):
	+ case CCHR('?'):
	+ is_undo(&pptr, &dir);
	+ if (is_peek() != SRCH_ACCM)
	+ success = TRUE;
	+ is_prompt(dir, pptr < 0, success);
	+ break;
	+ case CCHR('\\'):
	+ case CCHR('Q'):
	+ c = (char)getkey(FALSE);
	+ goto addchar;
	+ default:
	+ if (ISCTRL(c)) {
	+ ungetkey(c);
	+ curwp->w_markp = clp;
	+ curwp->w_marko = cbo;
	+ curwp->w_markline = cdotline;
	+ ewprintf("Mark set");
	+ curwp->w_rflag \|= WFMOVE;
	+ return (TRUE);
	+ }
	+ /* FALLTHRU */
	+ case CCHR('I'):
	+ case CCHR('J'):
	+ addchar:
	+ if (pptr == -1)
	+ pptr = 0;
	+ if (pptr == 0)
	+ success = TRUE;
	+ if (pptr == NPAT - 1)
	+ dobeep();
	+ else {
	+ pat[pptr++] = c;
	+ pat[pptr] = '\0';
	+ }
	+ is_lpush();
	+ if (success != FALSE) {
	+ if (is_find(dir) != FALSE)
	+ is_cpush(c);
	+ else {
	+ success = FALSE;
	+ dobeep();
	+ is_cpush(SRCH_ACCM);
	+ }
	+ } else
	+ is_cpush(SRCH_ACCM);
	+ is_prompt(dir, FALSE, success);
	+ }
	+ }
	+ /* NOTREACHED */
	+}
	+
	+static void
	+is_cpush(int cmd)
	+{
	+ if (++cip >= NSRCH)
	+ cip = 0;
	+ cmds[cip].s_code = cmd;
	+}
	+
	+static void
	+is_lpush(void)
	+{
	+ int ctp;
	+
	+ ctp = cip + 1;
	+ if (ctp >= NSRCH)
	+ ctp = 0;
	+ cmds[ctp].s_code = SRCH_NOPR;
	+ cmds[ctp].s_doto = curwp->w_doto;
	+ cmds[ctp].s_dotp = curwp->w_dotp;
	+ cmds[ctp].s_dotline = curwp->w_dotline;
	+}
	+
	+static void
	+is_pop(void)
	+{
	+ if (cmds[cip].s_code != SRCH_NOPR) {
	+ curwp->w_doto = cmds[cip].s_doto;
	+ curwp->w_dotp = cmds[cip].s_dotp;
	+ curwp->w_dotline = cmds[cip].s_dotline;
	+ curwp->w_rflag \|= WFMOVE;
	+ cmds[cip].s_code = SRCH_NOPR;
	+ }
	+ if (--cip <= 0)
	+ cip = NSRCH - 1;
	+}
	+
	+static int
	+is_peek(void)
	+{
	+ return (cmds[cip].s_code);
	+}
	+
	+/* this used to always return TRUE (the return value was checked) */
	+static void
	+is_undo(int pptr, int dir)
	+{
	+ int redo = FALSE;
	+
	+ switch (cmds[cip].s_code) {
	+ case SRCH_BEGIN:
	+ case SRCH_NOPR:
	+ *pptr = -1;
	+ break;
	+ case SRCH_MARK:
	+ break;
	+ case SRCH_FORW:
	+ *dir = SRCH_BACK;
	+ redo = TRUE;
	+ break;
	+ case SRCH_BACK:
	+ *dir = SRCH_FORW;
	+ redo = TRUE;
	+ break;
	+ case SRCH_ACCM:
	+ default:
	+ *pptr -= 1;
	+ if (*pptr < 0)
	+ *pptr = 0;
	+ pat[*pptr] = '\0';
	+ break;
	+ }
	+ is_pop();
	+ if (redo)
	+ is_undo(pptr, dir);
	+}
	+
	+static int
	+is_find(int dir)
	+{
	+ int plen, odoto, odotline;
	+ struct line *odotp;
	+
	+ odoto = curwp->w_doto;
	+ odotp = curwp->w_dotp;
	+ odotline = curwp->w_dotline;
	+ plen = strlen(pat);
	+ if (plen != 0) {
	+ if (dir == SRCH_FORW) {
	+ (void)backchar(FFARG \| FFRAND, plen);
	+ if (forwsrch() == FALSE) {
	+ curwp->w_doto = odoto;
	+ curwp->w_dotp = odotp;
	+ curwp->w_dotline = odotline;
	+ return (FALSE);
	+ }
	+ return (TRUE);
	+ }
	+ if (dir == SRCH_BACK) {
	+ (void)forwchar(FFARG \| FFRAND, plen);
	+ if (backsrch() == FALSE) {
	+ curwp->w_doto = odoto;
	+ curwp->w_dotp = odotp;
	+ curwp->w_dotline = odotline;
	+ return (FALSE);
	+ }
	+ return (TRUE);
	+ }
	+ dobeep();
	+ ewprintf("bad call to is_find");
	+ return (FALSE);
	+ }
	+ return (FALSE);
	+}
	+
	+/*
	+ * If called with "dir" not one of SRCH_FORW or SRCH_BACK, this routine used
	+ * to print an error message. It also used to return TRUE or FALSE, depending
	+ * on if it liked the "dir". However, none of the callers looked at the
	+ * status, so I just made the checking vanish.
	+ */
	+static void
	+is_prompt(int dir, int flag, int success)
	+{
	+ if (dir == SRCH_FORW) {
	+ if (success != FALSE)
	+ is_dspl("I-search", flag);
	+ else
	+ is_dspl("Failing I-search", flag);
	+ } else if (dir == SRCH_BACK) {
	+ if (success != FALSE)
	+ is_dspl("I-search backward", flag);
	+ else
	+ is_dspl("Failing I-search backward", flag);
	+ } else
	+ ewprintf("Broken call to is_prompt");
	+}
	+
	+/*
	+ * Prompt writing routine for the incremental search. The "i_prompt" is just
	+ * a string. The "flag" determines whether pat should be printed.
	+ */
	+static void
	+is_dspl(char *i_prompt, int flag)
	+{
	+ if (flag != FALSE)
	+ ewprintf("%s: ", i_prompt);
	+ else
	+ ewprintf("%s: %s", i_prompt, pat);
	+}
	+
	+/*
	+ * Query Replace.
	+ * Replace strings selectively. Does a search and replace operation.
	+ */
	+/* ARGSUSED */
	+int
	+queryrepl(int f, int n)
	+{
	+ int s;
	+ int rcnt = 0; /* replacements made so far */
	+ int plen; /* length of found string */
	+ char news[NPAT], rep; / replacement string */
	+
	+ if (macrodef) {
	+ dobeep();
	+ ewprintf("Can't query replace in macro");
	+ return (FALSE);
	+ }
	+
	+ if ((s = readpattern("Query replace")) != TRUE)
	+ return (s);
	+ if ((rep = eread("Query replace %s with: ", news, NPAT,
	+ EFNUL \| EFNEW \| EFCR, pat)) == NULL)
	+ return (ABORT);
	+ else if (rep[0] == '\0')
	+ news[0] = '\0';
	+ ewprintf("Query replacing %s with %s:", pat, news);
	+ plen = strlen(pat);
	+
	+ /*
	+ * Search forward repeatedly, checking each time whether to insert
	+ * or not. The "!" case makes the check always true, so it gets put
	+ * into a tighter loop for efficiency.
	+ */
	+ while (forwsrch() == TRUE) {
	+retry:
	+ update(CMODE);
	+ switch (getkey(FALSE)) {
	+ case 'y':
	+ case ' ':
	+ if (lreplace((RSIZE)plen, news) == FALSE)
	+ return (FALSE);
	+ rcnt++;
	+ break;
	+ case '.':
	+ if (lreplace((RSIZE)plen, news) == FALSE)
	+ return (FALSE);
	+ rcnt++;
	+ goto stopsearch;
	+ /* ^G, CR or ESC */
	+ case CCHR('G'):
	+ (void)ctrlg(FFRAND, 0);
	+ goto stopsearch;
	+ case CCHR('['):
	+ case CCHR('M'):
	+ goto stopsearch;
	+ case '!':
	+ do {
	+ if (lreplace((RSIZE)plen, news) == FALSE)
	+ return (FALSE);
	+ rcnt++;
	+ } while (forwsrch() == TRUE);
	+ goto stopsearch;
	+ case 'n':
	+ case CCHR('H'):
	+ /* To not replace */
	+ case CCHR('?'):
	+ break;
	+ default:
	+ ewprintf("y/n or <SP>/<DEL>: replace/don't, [.] repl-end, [!] repl-rest, <CR>/<ESC> quit");
	+ goto retry;
	+ }
	+ }
	+stopsearch:
	+ curwp->w_rflag \|= WFFULL;
	+ update(CMODE);
	+ if (rcnt == 1)
	+ ewprintf("Replaced 1 occurrence");
	+ else
	+ ewprintf("Replaced %d occurrences", rcnt);
	+ return (TRUE);
	+}
	+
	+/*
	+ * Replace string globally without individual prompting.
	+ */
	+/* ARGSUSED */
	+int
	+replstr(int f, int n)
	+{
	+ char news[NPAT];
	+ int s, plen, rcnt = 0;
	+ char *r;
	+
	+ if ((s = readpattern("Replace string")) != TRUE)
	+ return s;
	+
	+ r = eread("Replace string %s with: ", news, NPAT,
	+ EFNUL \| EFNEW \| EFCR, pat);
	+ if (r == NULL)
	+ return (ABORT);
	+
	+ plen = strlen(pat);
	+ while (forwsrch() == TRUE) {
	+ update(CMODE);
	+ if (lreplace((RSIZE)plen, news) == FALSE)
	+ return (FALSE);
	+
	+ rcnt++;
	+ }
	+
	+ curwp->w_rflag \|= WFFULL;
	+ update(CMODE);
	+
	+ if (rcnt == 1)
	+ ewprintf("Replaced 1 occurrence");
	+ else
	+ ewprintf("Replaced %d occurrences", rcnt);
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * This routine does the real work of a forward search. The pattern is sitting
	+ * in the external variable "pat". If found, dot is updated, the window system
	+ * is notified of the change, and TRUE is returned. If the string isn't found,
	+ * FALSE is returned.
	+ */
	+int
	+forwsrch(void)
	+{
	+ struct line clp, tlp;
	+ int cbo, tbo, c, i, xcase = 0;
	+ char *pp;
	+ int nline;
	+
	+ clp = curwp->w_dotp;
	+ cbo = curwp->w_doto;
	+ nline = curwp->w_dotline;
	+ for (i = 0; pat[i]; i++)
	+ if (ISUPPER(CHARMASK(pat[i])))
	+ xcase = 1;
	+ for (;;) {
	+ if (cbo == llength(clp)) {
	+ if ((clp = lforw(clp)) == curbp->b_headp)
	+ break;
	+ nline++;
	+ cbo = 0;
	+ c = CCHR('J');
	+ } else
	+ c = lgetc(clp, cbo++);
	+ if (eq(c, pat[0], xcase) != FALSE) {
	+ tlp = clp;
	+ tbo = cbo;
	+ pp = &pat[1];
	+ while (*pp != 0) {
	+ if (tbo == llength(tlp)) {
	+ tlp = lforw(tlp);
	+ if (tlp == curbp->b_headp)
	+ goto fail;
	+ tbo = 0;
	+ c = CCHR('J');
	+ if (eq(c, *pp++, xcase) == FALSE)
	+ goto fail;
	+ nline++;
	+ } else {
	+ c = lgetc(tlp, tbo++);
	+ if (eq(c, *pp++, xcase) == FALSE)
	+ goto fail;
	+ }
	+ }
	+ curwp->w_dotp = tlp;
	+ curwp->w_doto = tbo;
	+ curwp->w_dotline = nline;
	+ curwp->w_rflag \|= WFMOVE;
	+ return (TRUE);
	+ }
	+fail: ;
	+ }
	+ return (FALSE);
	+}
	+
	+/*
	+ * This routine does the real work of a backward search. The pattern is
	+ * sitting in the external variable "pat". If found, dot is updated, the
	+ * window system is notified of the change, and TRUE is returned. If the
	+ * string isn't found, FALSE is returned.
	+ */
	+int
	+backsrch(void)
	+{
	+ struct line clp, tlp;
	+ int cbo, tbo, c, i, xcase = 0;
	+ char epp, pp;
	+ int nline, pline;
	+
	+ for (epp = &pat[0]; epp[1] != 0; ++epp);
	+ clp = curwp->w_dotp;
	+ cbo = curwp->w_doto;
	+ nline = curwp->w_dotline;
	+ for (i = 0; pat[i]; i++)
	+ if (ISUPPER(CHARMASK(pat[i])))
	+ xcase = 1;
	+ for (;;) {
	+ if (cbo == 0) {
	+ clp = lback(clp);
	+ if (clp == curbp->b_headp)
	+ return (FALSE);
	+ nline--;
	+ cbo = llength(clp) + 1;
	+ }
	+ if (--cbo == llength(clp))
	+ c = CCHR('J');
	+ else
	+ c = lgetc(clp, cbo);
	+ if (eq(c, *epp, xcase) != FALSE) {
	+ tlp = clp;
	+ tbo = cbo;
	+ pp = epp;
	+ pline = nline;
	+ while (pp != &pat[0]) {
	+ if (tbo == 0) {
	+ tlp = lback(tlp);
	+ if (tlp == curbp->b_headp)
	+ goto fail;
	+ nline--;
	+ tbo = llength(tlp) + 1;
	+ }
	+ if (--tbo == llength(tlp))
	+ c = CCHR('J');
	+ else
	+ c = lgetc(tlp, tbo);
	+ if (eq(c, *--pp, xcase) == FALSE) {
	+ nline = pline;
	+ goto fail;
	+ }
	+ }
	+ curwp->w_dotp = tlp;
	+ curwp->w_doto = tbo;
	+ curwp->w_dotline = nline;
	+ curwp->w_rflag \|= WFMOVE;
	+ return (TRUE);
	+ }
	+fail: ;
	+ }
	+ /* NOTREACHED */
	+}
	+
	+/*
	+ * Compare two characters. The "bc" comes from the buffer. It has its case
	+ * folded out. The "pc" is from the pattern.
	+ */
	+static int
	+eq(int bc, int pc, int xcase)
	+{
	+ bc = CHARMASK(bc);
	+ pc = CHARMASK(pc);
	+ if (bc == pc)
	+ return (TRUE);
	+ if (xcase)
	+ return (FALSE);
	+ if (ISUPPER(bc))
	+ return (TOLOWER(bc) == pc);
	+ if (ISUPPER(pc))
	+ return (bc == TOLOWER(pc));
	+ return (FALSE);
	+}
	+
	+/*
	+ * Read a pattern. Stash it in the external variable "pat". The "pat" is not
	+ * updated if the user types in an empty line. If the user typed an empty
	+ * line, and there is no old pattern, it is an error. Display the old pattern,
	+ * in the style of Jeff Lomicka. There is some do-it-yourself control
	+ * expansion.
	+ */
	+int
	+readpattern(char *r_prompt)
	+{
	+ char tpat[NPAT], *rep;
	+ int retval;
	+
	+ if (pat[0] == '\0')
	+ rep = eread("%s: ", tpat, NPAT, EFNEW \| EFCR, r_prompt);
	+ else
	+ rep = eread("%s (default %s): ", tpat, NPAT,
	+ EFNUL \| EFNEW \| EFCR, r_prompt, pat);
	+
	+ /* specified */
	+ if (rep == NULL) {
	+ retval = ABORT;
	+ } else if (rep[0] != '\0') {
	+ (void)strlcpy(pat, tpat, sizeof(pat));
	+ retval = TRUE;
	+ } else if (pat[0] != '\0') {
	+ retval = TRUE;
	+ } else
	+ retval = FALSE;
	+ return (retval);
	+}
	Index: contrib/mg/setupterm.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/setupterm.c
	@@ -0,0 +1,158 @@
	+/* $NetBSD: setupterm.c,v 1.9 2019/04/11 23:52:08 jakllsch Exp $ */
	+
	+/*
	+ * Copyright (c) 2009, 2011 The NetBSD Foundation, Inc.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Roy Marples.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ */
	+
	+#include <sys/cdefs.h>
	+
	+#include <sys/ioctl.h>
	+#include <err.h>
	+#include <stdbool.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <strings.h>
	+#include <unistd.h>
	+
	+#include "term_private.h"
	+#include "terminfo_term.h"
	+
	+/*
	+ * use_env is really a curses function - POSIX mandates it's in curses.h
	+ * But it has to live in terminfo because it must precede a call to setupterm().
	+ */
	+
	+static bool __use_env = true;
	+
	+void
	+use_env(bool value)
	+{
	+
	+ __use_env = value;
	+}
	+#define reterr(code, msg) \
	+ do { \
	+ if (errret == NULL) \
	+ errx(EXIT_FAILURE, msg); \
	+ else { \
	+ *errret = code; \
	+ return ERR; \
	+ } \
	+ } while (0 /* CONSTCOND */)
	+
	+#define reterrarg(code, msg, arg) \
	+ do { \
	+ if (errret == NULL) \
	+ errx(EXIT_FAILURE, msg, arg); \
	+ else { \
	+ *errret = code; \
	+ return ERR; \
	+ } \
	+ } while (0 /* CONSTCOND */)
	+
	+
	+int
	+ti_setupterm(TERMINAL *nterm, const char term, int fildes, int *errret)
	+{
	+ int error;
	+ struct winsize win;
	+
	+ if (term == NULL)
	+ term = getenv("TERM");
	+ if (term == NULL \|\| *term == '\0') {
	+ *nterm = NULL;
	+ reterr(0, "TERM environment variable not set");
	+ }
	+ if (fildes == STDOUT_FILENO && !isatty(fildes))
	+ fildes = STDERR_FILENO;
	+
	+ nterm = calloc(1, sizeof(*nterm));
	+ if (*nterm == NULL)
	+ reterr(-1, "not enough memory to create terminal structure");
	+
	+ error = _ti_getterm(*nterm, term, 0);
	+ if (error != 1) {
	+ del_curterm(*nterm);
	+ *nterm = NULL;
	+ switch (error) {
	+ case -1:
	+ reterr(error, "cannot access the terminfo database");
	+ /* NOTREACHED */
	+ case 0:
	+ reterrarg(error,
	+ "%s: terminal not listed in terminfo database",
	+ term);
	+ /* NOTREACHED */
	+ default:
	+ reterr(-1, "unknown error");
	+ /* NOTREACHED */
	+ }
	+ }
	+
	+ (*nterm)->fildes = fildes;
	+ _ti_setospeed(*nterm);
	+ if (t_generic_type(*nterm))
	+ reterrarg(0, "%s: generic terminal", term);
	+ if (t_hard_copy(*nterm))
	+ reterrarg(1, "%s: hardcopy terminal", term);
	+
	+ /* If TIOCGWINSZ works, then set initial lines and columns. */
	+ if (ioctl(fildes, TIOCGWINSZ, &win) != -1 &&
	+ win.ws_row != 0 && win.ws_col != 0)
	+ {
	+ t_lines(*nterm) = (short)win.ws_row;
	+ t_columns(*nterm) = (short)win.ws_col;
	+ }
	+
	+ /* POSIX 1003.2 requires that the environment override. */
	+ if (__use_env) {
	+ char *p;
	+
	+ if ((p = getenv("LINES")) != NULL)
	+ t_lines(*nterm) = (short)strtol(p, NULL, 0);
	+ if ((p = getenv("COLUMNS")) != NULL)
	+ t_columns(*nterm) = (short)strtol(p, NULL, 0);
	+ }
	+
	+ /* POSIX requires 1 for success */
	+ if (errret)
	+ *errret = 1;
	+ return OK;
	+}
	+
	+int
	+setupterm(const char term, int fildes, int errret)
	+{
	+ TERMINAL *nterm;
	+ int ret;
	+
	+ if (errret != NULL)
	+ *errret = ERR;
	+ ret = ti_setupterm(&nterm, term, fildes, errret);
	+ if (nterm != NULL)
	+ set_curterm(nterm);
	+ return ret;
	+}
	Index: contrib/mg/spawn.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/spawn.c
	@@ -0,0 +1,51 @@
	+/* $OpenBSD: spawn.c,v 1.12 2015/03/19 21:22:15 bcallah Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * Spawn. Actually just suspends Mg.
	+ * Assumes POSIX job control.
	+ */
	+
	+#include <sys/queue.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <term.h>
	+#include <termios.h>
	+
	+#include "def.h"
	+
	+/*
	+ * This causes mg to send itself a stop signal. It assumes the parent
	+ * shell supports POSIX job control. If the terminal supports an alternate
	+ * screen, we will switch to it.
	+ */
	+/* ARGSUSED */
	+int
	+spawncli(int f, int n)
	+{
	+ sigset_t oset;
	+
	+ /* Very similar to what vttidy() does. */
	+ ttcolor(CTEXT);
	+ ttnowindow();
	+ ttmove(nrow - 1, 0);
	+ if (epresf != FALSE) {
	+ tteeol();
	+ epresf = FALSE;
	+ }
	+ if (ttcooked() == FALSE)
	+ return (FALSE);
	+
	+ /* Exit application mode and tidy. */
	+ tttidy();
	+ ttflush();
	+ (void)sigprocmask(SIG_SETMASK, NULL, &oset);
	+ (void)kill(0, SIGTSTP);
	+ (void)sigprocmask(SIG_SETMASK, &oset, NULL);
	+ ttreinit();
	+
	+ /* Force repaint. */
	+ sgarbf = TRUE;
	+ return (ttraw());
	+}
	Index: contrib/mg/strlcat.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/strlcat.c
	@@ -0,0 +1,61 @@
	+/* $OpenBSD: strlcat.c,v 1.15 2015/03/02 21:41:08 millert Exp $ */
	+
	+/*
	+ * Copyright (c) 1998, 2015 Todd C. Miller <Todd.Miller@courtesan.com>
	+ *
	+ * Permission to use, copy, modify, and distribute this software for any
	+ * purpose with or without fee is hereby granted, provided that the above
	+ * copyright notice and this permission notice appear in all copies.
	+ *
	+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	+ */
	+
	+#include <sys/types.h>
	+#include <string.h>
	+
	+#include "config.h"
	+
	+#ifndef HAVE_STRLCAT
	+
	+/*
	+ * Appends src to string dst of size dsize (unlike strncat, dsize is the
	+ * full size of dst, not space left). At most dsize-1 characters
	+ * will be copied. Always NUL terminates (unless dsize <= strlen(dst)).
	+ * Returns strlen(src) + MIN(dsize, strlen(initial dst)).
	+ * If retval >= dsize, truncation occurred.
	+ */
	+size_t
	+strlcat(char dst, const char src, size_t dsize)
	+{
	+ const char *odst = dst;
	+ const char *osrc = src;
	+ size_t n = dsize;
	+ size_t dlen;
	+
	+ /* Find the end of dst and adjust bytes left but don't go past end. */
	+ while (n-- != 0 && *dst != '\0')
	+ dst++;
	+ dlen = dst - odst;
	+ n = dsize - dlen;
	+
	+ if (n-- == 0)
	+ return(dlen + strlen(src));
	+ while (*src != '\0') {
	+ if (n != 0) {
	+ dst++ = src;
	+ n--;
	+ }
	+ src++;
	+ }
	+ *dst = '\0';
	+
	+ return(dlen + (src - osrc)); /* count does not include NUL */
	+}
	+
	+#endif /* !HAVE_STRLCAT */
	Index: contrib/mg/strlcpy.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/strlcpy.c
	@@ -0,0 +1,56 @@
	+/* $OpenBSD: strlcpy.c,v 1.12 2015/01/15 03:54:12 millert Exp $ */
	+
	+/*
	+ * Copyright (c) 1998, 2015 Todd C. Miller <Todd.Miller@courtesan.com>
	+ *
	+ * Permission to use, copy, modify, and distribute this software for any
	+ * purpose with or without fee is hereby granted, provided that the above
	+ * copyright notice and this permission notice appear in all copies.
	+ *
	+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	+ */
	+
	+#include <sys/types.h>
	+#include <string.h>
	+
	+#include "config.h"
	+
	+#ifndef HAVE_STRLCPY
	+
	+/*
	+ * Copy string src to buffer dst of size dsize. At most dsize-1
	+ * chars will be copied. Always NUL terminates (unless dsize == 0).
	+ * Returns strlen(src); if retval >= dsize, truncation occurred.
	+ */
	+size_t
	+strlcpy(char dst, const char src, size_t dsize)
	+{
	+ const char *osrc = src;
	+ size_t nleft = dsize;
	+
	+ /* Copy as many bytes as will fit. */
	+ if (nleft != 0) {
	+ while (--nleft != 0) {
	+ if ((dst++ = src++) == '\0')
	+ break;
	+ }
	+ }
	+
	+ /* Not enough room in dst, add NUL and traverse rest of src. */
	+ if (nleft == 0) {
	+ if (dsize != 0)
	+ dst = '\0'; / NUL-terminate dst */
	+ while (*src++)
	+ ;
	+ }
	+
	+ return(src - osrc - 1); /* count does not include NUL */
	+}
	+
	+#endif /* !HAVE_STRLCPY */
	Index: contrib/mg/strndup.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/strndup.c
	@@ -0,0 +1,55 @@
	+/* $OpenBSD: strndup.c,v 1.3 2019/01/25 00:19:25 millert Exp $ */
	+/* $OpenBSD: strnlen.c,v 1.9 2019/01/25 00:19:25 millert Exp $ */
	+
	+/*
	+ * Copyright (c) 2010 Todd C. Miller <millert@openbsd.org>
	+ *
	+ * Permission to use, copy, modify, and distribute this software for any
	+ * purpose with or without fee is hereby granted, provided that the above
	+ * copyright notice and this permission notice appear in all copies.
	+ *
	+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	+ */
	+
	+#include <stddef.h>
	+#include <stdlib.h>
	+#include <string.h>
	+
	+#include "config.h"
	+
	+#ifndef HAVE_STRNDUP
	+
	+static size_t
	+strnlen(const char *str, size_t maxlen)
	+{
	+ const char *cp;
	+
	+ for (cp = str; maxlen != 0 && *cp != '\0'; cp++, maxlen--)
	+ ;
	+
	+ return (size_t)(cp - str);
	+}
	+
	+char *
	+strndup(const char *str, size_t maxlen)
	+{
	+ char *copy;
	+ size_t len;
	+
	+ len = strnlen(str, maxlen);
	+ copy = malloc(len + 1);
	+ if (copy != NULL) {
	+ (void)memcpy(copy, str, len);
	+ copy[len] = '\0';
	+ }
	+
	+ return copy;
	+}
	+
	+#endif /* !HAVE_STRNDUP */
	Index: contrib/mg/strtonum.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/strtonum.c
	@@ -0,0 +1,71 @@
	+/* $OpenBSD: strtonum.c,v 1.7 2013/04/17 18:40:58 tedu Exp $ */
	+
	+/*
	+ * Copyright (c) 2004 Ted Unangst and Todd Miller
	+ * All rights reserved.
	+ *
	+ * Permission to use, copy, modify, and distribute this software for any
	+ * purpose with or without fee is hereby granted, provided that the above
	+ * copyright notice and this permission notice appear in all copies.
	+ *
	+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	+ */
	+
	+#include <errno.h>
	+#include <limits.h>
	+#include <stdlib.h>
	+
	+#include "config.h"
	+
	+#ifndef HAVE_STRTONUM
	+
	+#define INVALID 1
	+#define TOOSMALL 2
	+#define TOOLARGE 3
	+
	+long long
	+strtonum(const char *numstr, long long minval, long long maxval,
	+ const char **errstrp)
	+{
	+ long long ll = 0;
	+ int error = 0;
	+ char *ep;
	+ struct errval {
	+ const char *errstr;
	+ int err;
	+ } ev[4] = {
	+ { NULL, 0 },
	+ { "invalid", EINVAL },
	+ { "too small", ERANGE },
	+ { "too large", ERANGE },
	+ };
	+
	+ ev[0].err = errno;
	+ errno = 0;
	+ if (minval > maxval) {
	+ error = INVALID;
	+ } else {
	+ ll = strtoll(numstr, &ep, 10);
	+ if (numstr == ep \|\| *ep != '\0')
	+ error = INVALID;
	+ else if ((ll == LLONG_MIN && errno == ERANGE) \|\| ll < minval)
	+ error = TOOSMALL;
	+ else if ((ll == LLONG_MAX && errno == ERANGE) \|\| ll > maxval)
	+ error = TOOLARGE;
	+ }
	+ if (errstrp != NULL)
	+ *errstrp = ev[error].errstr;
	+ errno = ev[error].err;
	+ if (error)
	+ ll = 0;
	+
	+ return (ll);
	+}
	+
	+#endif /* !HAVE_STRTONUM */
	Index: contrib/mg/tags.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/tags.c
	@@ -0,0 +1,565 @@
	+/* $OpenBSD: tags.c,v 1.16 2017/08/06 04:39:45 bcallah Exp $ */
	+
	+/*
	+ * This file is in the public domain.
	+ *
	+ * Author: Sunil Nimmagadda <sunil@openbsd.org>
	+ */
	+
	+#include <sys/queue.h>
	+#include <sys/stat.h>
	+#if defined(__linux__) \|\| defined(__DragonFly__) \|\| defined(__APPLE__)
	+#include "tree.h"
	+#else
	+#include <sys/tree.h>
	+#endif
	+#include <sys/types.h>
	+#include <ctype.h>
	+#include <err.h>
	+#include <errno.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+#include <unistd.h>
	+#if defined(__linux__) \|\| defined(__CYGWIN__)
	+#include "util.h"
	+#elif defined(__OpenBSD__) \|\| defined(__NetBSD__) \|\| defined(__APPLE__)
	+#include <util.h>
	+#else
	+#include <libutil.h>
	+#endif
	+
	+#include "def.h"
	+
	+struct ctag;
	+
	+static int addctag(char *);
	+static int atbow(void);
	+void closetags(void);
	+static int ctagcmp(struct ctag , struct ctag );
	+static int loadbuffer(char *);
	+static int loadtags(const char *);
	+static int pushtag(char *);
	+static int searchpat(char *);
	+static struct ctag searchtag(char );
	+static char strip(char , size_t);
	+static void unloadtags(void);
	+
	+#define DEFAULTFN "tags"
	+
	+char *tagsfn = NULL;
	+int loaded = FALSE;
	+
	+/* ctags(1) entries are parsed and maintained in a tree. */
	+struct ctag {
	+ RB_ENTRY(ctag) entry;
	+ char *tag;
	+ char *fname;
	+ char *pat;
	+};
	+RB_HEAD(tagtree, ctag) tags = RB_INITIALIZER(&tags);
	+RB_GENERATE(tagtree, ctag, entry, ctagcmp);
	+
	+struct tagpos {
	+ SLIST_ENTRY(tagpos) entry;
	+ int doto;
	+ int dotline;
	+ char *bname;
	+};
	+SLIST_HEAD(tagstack, tagpos) shead = SLIST_HEAD_INITIALIZER(shead);
	+
	+int
	+ctagcmp(struct ctag s, struct ctag t)
	+{
	+ return strcmp(s->tag, t->tag);
	+}
	+
	+/*
	+ * Record the filename that contain tags to be used while loading them
	+ * on first use. If a filename is already recorded, ask user to retain
	+ * already loaded tags (if any) and unload them if user chooses not to.
	+ */
	+/* ARGSUSED */
	+int
	+tagsvisit(int f, int n)
	+{
	+ char fname[NFILEN], bufp, temp;
	+ struct stat sb;
	+
	+ if (getbufcwd(fname, sizeof(fname)) == FALSE)
	+ fname[0] = '\0';
	+
	+ if (strlcat(fname, DEFAULTFN, sizeof(fname)) >= sizeof(fname)) {
	+ dobeep();
	+ ewprintf("Filename too long");
	+ return (FALSE);
	+ }
	+
	+ bufp = eread("Visit tags table (default %s): ", fname,
	+ NFILEN, EFFILE \| EFCR \| EFNEW \| EFDEF, DEFAULTFN);
	+ if (bufp == NULL)
	+ return (ABORT);
	+
	+ if (stat(bufp, &sb) == -1) {
	+ dobeep();
	+ ewprintf("stat: %s", strerror(errno));
	+ return (FALSE);
	+ } else if (S_ISREG(sb.st_mode) == 0) {
	+ dobeep();
	+ ewprintf("Not a regular file");
	+ return (FALSE);
	+ } else if (access(bufp, R_OK) == -1) {
	+ dobeep();
	+ ewprintf("Cannot access file %s", bufp);
	+ return (FALSE);
	+ }
	+
	+ if (tagsfn == NULL) {
	+ if (bufp[0] == '\0') {
	+ if ((tagsfn = strdup(fname)) == NULL) {
	+ dobeep();
	+ ewprintf("Out of memory");
	+ return (FALSE);
	+ }
	+ } else {
	+ /* bufp points to local variable, so duplicate. */
	+ if ((tagsfn = strdup(bufp)) == NULL) {
	+ dobeep();
	+ ewprintf("Out of memory");
	+ return (FALSE);
	+ }
	+ }
	+ } else {
	+ if ((temp = strdup(bufp)) == NULL) {
	+ dobeep();
	+ ewprintf("Out of memory");
	+ return (FALSE);
	+ }
	+ free(tagsfn);
	+ tagsfn = temp;
	+ if (eyorn("Keep current list of tags table also") == FALSE) {
	+ ewprintf("Starting a new list of tags table");
	+ unloadtags();
	+ }
	+ loaded = FALSE;
	+ }
	+ return (TRUE);
	+}
	+
	+/*
	+ * Ask user for a tag while treating word at dot as default. Visit tags
	+ * file if not yet done, load tags and jump to definition of the tag.
	+ */
	+int
	+findtag(int f, int n)
	+{
	+ char utok[MAX_TOKEN], dtok[MAX_TOKEN];
	+ char tok, bufp;
	+ int ret;
	+
	+ if (curtoken(f, n, dtok) == FALSE) {
	+ dtok[0] = '\0';
	+ bufp = eread("Find tag: ", utok, MAX_TOKEN, EFNUL \| EFNEW);
	+ } else
	+ bufp = eread("Find tag (default %s): ", utok, MAX_TOKEN,
	+ EFNUL \| EFNEW, dtok);
	+
	+ if (bufp == NULL)
	+ return (ABORT);
	+ else if (bufp[0] == '\0')
	+ tok = dtok;
	+ else
	+ tok = utok;
	+
	+ if (tok[0] == '\0') {
	+ dobeep();
	+ ewprintf("There is no default tag");
	+ return (FALSE);
	+ }
	+
	+ if (tagsfn == NULL)
	+ if ((ret = tagsvisit(f, n)) != TRUE)
	+ return (ret);
	+ if (!loaded) {
	+ if (loadtags(tagsfn) == FALSE) {
	+ free(tagsfn);
	+ tagsfn = NULL;
	+ return (FALSE);
	+ }
	+ loaded = TRUE;
	+ }
	+ return pushtag(tok);
	+}
	+
	+/*
	+ * Free tags tree.
	+ */
	+void
	+unloadtags(void)
	+{
	+ struct ctag var, nxt;
	+
	+ for (var = RB_MIN(tagtree, &tags); var != NULL; var = nxt) {
	+ nxt = RB_NEXT(tagtree, &tags, var);
	+ RB_REMOVE(tagtree, &tags, var);
	+ /* line parsed with fparseln needs to be freed */
	+ free(var->tag);
	+ free(var);
	+ }
	+}
	+
	+/*
	+ * Lookup tag passed in tree and if found, push current location and
	+ * buffername onto stack, load the file with tag definition into a new
	+ * buffer and position dot at the pattern.
	+ */
	+/ARGSUSED /
	+int
	+pushtag(char *tok)
	+{
	+ struct ctag *res;
	+ struct tagpos *s;
	+ char bname[NFILEN];
	+ int doto, dotline;
	+
	+ if ((res = searchtag(tok)) == NULL)
	+ return (FALSE);
	+
	+ doto = curwp->w_doto;
	+ dotline = curwp->w_dotline;
	+ /* record absolute filenames. Fixes issues when mg's cwd is not the
	+ * same as buffer's directory.
	+ */
	+ if (strlcpy(bname, curbp->b_cwd, sizeof(bname)) >= sizeof(bname)) {
	+ dobeep();
	+ ewprintf("filename too long");
	+ return (FALSE);
	+ }
	+ if (strlcat(bname, curbp->b_bname, sizeof(bname)) >= sizeof(bname)) {
	+ dobeep();
	+ ewprintf("filename too long");
	+ return (FALSE);
	+ }
	+
	+ if (loadbuffer(res->fname) == FALSE)
	+ return (FALSE);
	+
	+ if (searchpat(res->pat) == TRUE) {
	+ if ((s = malloc(sizeof(struct tagpos))) == NULL) {
	+ dobeep();
	+ ewprintf("Out of memory");
	+ return (FALSE);
	+ }
	+ if ((s->bname = strdup(bname)) == NULL) {
	+ dobeep();
	+ ewprintf("Out of memory");
	+ free(s);
	+ return (FALSE);
	+ }
	+ s->doto = doto;
	+ s->dotline = dotline;
	+ SLIST_INSERT_HEAD(&shead, s, entry);
	+ return (TRUE);
	+ } else {
	+ dobeep();
	+ ewprintf("%s: pattern not found", res->tag);
	+ return (FALSE);
	+ }
	+ /* NOTREACHED */
	+ return (FALSE);
	+}
	+
	+/*
	+ * If tag stack is not empty pop stack and jump to recorded buffer, dot.
	+ */
	+/* ARGSUSED */
	+int
	+poptag(int f, int n)
	+{
	+ struct line *dotp;
	+ struct tagpos *s;
	+
	+ if (SLIST_EMPTY(&shead)) {
	+ dobeep();
	+ ewprintf("No previous location for find-tag invocation");
	+ return (FALSE);
	+ }
	+ s = SLIST_FIRST(&shead);
	+ SLIST_REMOVE_HEAD(&shead, entry);
	+ if (loadbuffer(s->bname) == FALSE)
	+ return (FALSE);
	+ curwp->w_dotline = s->dotline;
	+ curwp->w_doto = s->doto;
	+
	+ /* storing of dotp in tagpos wouldn't work out in cases when
	+ * that buffer is killed by user(dangling pointer). Explicitly
	+ * traverse till dotline for correct handling.
	+ */
	+ dotp = curwp->w_bufp->b_headp;
	+ while (s->dotline--)
	+ dotp = dotp->l_fp;
	+
	+ curwp->w_dotp = dotp;
	+ free(s->bname);
	+ free(s);
	+ return (TRUE);
	+}
	+
	+/*
	+ * Parse the tags file and construct the tags tree. Remove escape
	+ * characters while parsing the file.
	+ */
	+int
	+loadtags(const char *fn)
	+{
	+ char *l;
	+ FILE *fd;
	+
	+ if ((fd = fopen(fn, "r")) == NULL) {
	+ dobeep();
	+ ewprintf("Unable to open tags file: %s", fn);
	+ return (FALSE);
	+ }
	+ while ((l = fparseln(fd, NULL, NULL, "\\\\\0",
	+ FPARSELN_UNESCCONT \| FPARSELN_UNESCREST)) != NULL) {
	+ if (addctag(l) == FALSE) {
	+ fclose(fd);
	+ return (FALSE);
	+ }
	+ }
	+ fclose(fd);
	+ return (TRUE);
	+}
	+
	+/*
	+ * Cleanup and destroy tree and stack.
	+ */
	+void
	+closetags(void)
	+{
	+ struct tagpos *s;
	+
	+ while (!SLIST_EMPTY(&shead)) {
	+ s = SLIST_FIRST(&shead);
	+ SLIST_REMOVE_HEAD(&shead, entry);
	+ free(s->bname);
	+ free(s);
	+ }
	+ unloadtags();
	+ free(tagsfn);
	+}
	+
	+/*
	+ * Strip away any special characters in pattern.
	+ * The pattern in ctags isn't a true regular expression. Its of the form
	+ * /^xxx$/ or ?^xxx$? and in some cases the "$" would be missing. Strip
	+ * the leading and trailing special characters so the pattern matching
	+ * would be a simple string compare. Escape character is taken care by
	+ * fparseln.
	+ */
	+char *
	+strip(char *s, size_t len)
	+{
	+ /* first strip trailing special chars */
	+ s[len - 1] = '\0';
	+ if (s[len - 2] == '$')
	+ s[len - 2] = '\0';
	+
	+ /* then strip leading special chars */
	+ s++;
	+ if (*s == '^')
	+ s++;
	+
	+ return s;
	+}
	+
	+/*
	+ * tags line is of the format "<tag>\t<filename>\t<pattern>". Split them
	+ * by replacing '\t' with '\0'. This wouldn't alter the size of malloc'ed
	+ * l, and can be freed during cleanup.
	+ */
	+int
	+addctag(char *l)
	+{
	+ struct ctag *t;
	+
	+ if ((t = malloc(sizeof(struct ctag))) == NULL) {
	+ dobeep();
	+ ewprintf("Out of memory");
	+ return (FALSE);
	+ }
	+ t->tag = l;
	+ if ((l = strchr(l, '\t')) == NULL)
	+ goto cleanup;
	+ *l++ = '\0';
	+ t->fname = l;
	+ if ((l = strchr(l, '\t')) == NULL)
	+ goto cleanup;
	+ *l++ = '\0';
	+ if (*l == '\0')
	+ goto cleanup;
	+ t->pat = strip(l, strlen(l));
	+ RB_INSERT(tagtree, &tags, t);
	+ return (TRUE);
	+cleanup:
	+ free(t);
	+ free(l);
	+ return (FALSE);
	+}
	+
	+/*
	+ * Search through each line of buffer for pattern.
	+ */
	+int
	+searchpat(char *s_pat)
	+{
	+ struct line *lp;
	+ int dotline;
	+ size_t plen;
	+
	+ plen = strlen(s_pat);
	+ dotline = 1;
	+ lp = lforw(curbp->b_headp);
	+ while (lp != curbp->b_headp) {
	+ if (ltext(lp) != NULL && plen <= llength(lp) &&
	+ (strncmp(s_pat, ltext(lp), plen) == 0)) {
	+ curwp->w_doto = 0;
	+ curwp->w_dotp = lp;
	+ curwp->w_dotline = dotline;
	+ return (TRUE);
	+ } else {
	+ lp = lforw(lp);
	+ dotline++;
	+ }
	+ }
	+ return (FALSE);
	+}
	+
	+/*
	+ * Return TRUE if dot is at beginning of a word or at beginning
	+ * of line, else FALSE.
	+ */
	+int
	+atbow(void)
	+{
	+ if (curwp->w_doto == 0)
	+ return (TRUE);
	+ if (ISWORD(curwp->w_dotp->l_text[curwp->w_doto]) &&
	+ !ISWORD(curwp->w_dotp->l_text[curwp->w_doto - 1]))
	+ return (TRUE);
	+ return (FALSE);
	+}
	+
	+/*
	+ * Extract the word at dot without changing dot position.
	+ */
	+int
	+curtoken(int f, int n, char *token)
	+{
	+ struct line *odotp;
	+ int odoto, tdoto, odotline, size, r;
	+ char c;
	+
	+ /* Underscore character is to be treated as "inword" while
	+ * processing tokens unlike mg's default word traversal. Save
	+ * and restore it's cinfo value so that tag matching works for
	+ * identifier with underscore.
	+ */
	+ c = cinfo['_'];
	+ cinfo['_'] = _MG_W;
	+
	+ odotp = curwp->w_dotp;
	+ odoto = curwp->w_doto;
	+ odotline = curwp->w_dotline;
	+
	+ /* Move backword unless we are at the beginning of a word or at
	+ * beginning of line.
	+ */
	+ if (!atbow())
	+ if ((r = backword(f, n)) == FALSE)
	+ goto cleanup;
	+
	+ tdoto = curwp->w_doto;
	+
	+ if ((r = forwword(f, n)) == FALSE)
	+ goto cleanup;
	+
	+ /* strip away leading whitespace if any like emacs. */
	+ while (ltext(curwp->w_dotp) &&
	+ isspace(lgetc(curwp->w_dotp, tdoto)))
	+ tdoto++;
	+
	+ size = curwp->w_doto - tdoto;
	+ if (size <= 0 \|\| size >= MAX_TOKEN \|\|
	+ ltext(curwp->w_dotp) == NULL) {
	+ r = FALSE;
	+ goto cleanup;
	+ }
	+ strncpy(token, ltext(curwp->w_dotp) + tdoto, size);
	+ token[size] = '\0';
	+ r = TRUE;
	+
	+cleanup:
	+ cinfo['_'] = c;
	+ curwp->w_dotp = odotp;
	+ curwp->w_doto = odoto;
	+ curwp->w_dotline = odotline;
	+ return (r);
	+}
	+
	+/*
	+ * Search tagstree for a given token.
	+ */
	+struct ctag *
	+searchtag(char *tok)
	+{
	+ struct ctag t, *res;
	+
	+ t.tag = tok;
	+ if ((res = RB_FIND(tagtree, &tags, &t)) == NULL) {
	+ dobeep();
	+ ewprintf("No tag containing %s", tok);
	+ return (NULL);
	+ }
	+ return res;
	+}
	+
	+/*
	+ * This is equivalent to filevisit from file.c.
	+ * Look around to see if we can find the file in another buffer; if we
	+ * can't find it, create a new buffer, read in the text, and switch to
	+ * the new buffer. scratch, grep, compile needs to be handled
	+ * differently from other buffers which have "filenames".
	+ */
	+int
	+loadbuffer(char *bname)
	+{
	+ struct buffer *bufp;
	+ char *adjf;
	+
	+ /* check for special buffers which begin with '' /
	+ if (bname[0] == '*') {
	+ if ((bufp = bfind(bname, FALSE)) != NULL) {
	+ curbp = bufp;
	+ return (showbuffer(bufp, curwp, WFFULL));
	+ } else {
	+ return (FALSE);
	+ }
	+ } else {
	+ if ((adjf = adjustname(bname, TRUE)) == NULL)
	+ return (FALSE);
	+ if ((bufp = findbuffer(adjf)) == NULL)
	+ return (FALSE);
	+ }
	+ curbp = bufp;
	+ if (showbuffer(bufp, curwp, WFFULL) != TRUE)
	+ return (FALSE);
	+ if (bufp->b_fname[0] == '\0') {
	+ if (readin(adjf) != TRUE) {
	+ killbuffer(bufp);
	+ return (FALSE);
	+ }
	+ }
	+ return (TRUE);
	+}
	Index: contrib/mg/term.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/term.c
	@@ -0,0 +1,473 @@
	+/* $NetBSD: term.c,v 1.29 2018/10/08 20:44:34 roy Exp $ */
	+
	+/*
	+ * Copyright (c) 2009, 2010, 2011 The NetBSD Foundation, Inc.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Roy Marples.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ */
	+
	+#include <sys/cdefs.h>
	+#include <sys/stat.h>
	+
	+#include <ctype.h>
	+#include <errno.h>
	+#include <fcntl.h>
	+#include <limits.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+
	+#include "cdbr.h"
	+#include "term_private.h"
	+#include "terminfo_term.h"
	+
	+#define _PATH_TERMINFO "/usr/share/misc/terminfo"
	+
	+#ifndef __arraycount
	+#define __arraycount(__x) (sizeof(__x) / sizeof(__x[0]))
	+#endif
	+
	+static char __ti_database[PATH_MAX];
	+const char *_ti_database;
	+
	+/* From NetBSD sys/arch/hpc/stand/include/machine/endian.h */
	+uint16_t
	+le16dec(const void *buf)
	+{
	+ const uint8_t p = (const uint8_t )buf;
	+
	+ return ((p[1] << 8) \| p[0]);
	+}
	+
	+/* From NetBSD sys/external/bsd/libnv/dist/nv_compat.h */
	+static uint32_t
	+le32dec(const void *buf)
	+{
	+ uint8_t const p = (uint8_t const ) buf;
	+
	+ return (((unsigned) p[3] << 24) \| (p[2] << 16) \| (p[1] << 8) \| p[0]);
	+}
	+
	+/* Include a generated list of pre-compiled terminfo descriptions. */
	+#include "compiled_terms.c"
	+
	+static int
	+allocset(void *pp, int init, size_t nelem, size_t elemsize)
	+{
	+ void **p = pp;
	+ if (*p) {
	+ memset(p, init, nelem elemsize);
	+ return 0;
	+ }
	+
	+ if ((*p = calloc(nelem, elemsize)) == NULL)
	+ return -1;
	+
	+ if (init != 0)
	+ memset(p, init, nelem elemsize);
	+ return 0;
	+}
	+
	+static int
	+_ti_readterm(TERMINAL term, const char cap, size_t caplen, int flags)
	+{
	+ char ver;
	+ uint16_t ind, num;
	+ size_t len;
	+ TERMUSERDEF *ud;
	+
	+ if (caplen == 0)
	+ goto out;
	+ ver = *cap++;
	+ caplen--;
	+ /* Only read version 1 structures */
	+ if (ver != 1)
	+ goto out;
	+
	+ if (allocset(&term->flags, 0, TIFLAGMAX+1, sizeof(*term->flags)) == -1)
	+ return -1;
	+
	+ if (allocset(&term->nums, -1, TINUMMAX+1, sizeof(*term->nums)) == -1)
	+ return -1;
	+
	+ if (allocset(&term->strs, 0, TISTRMAX+1, sizeof(*term->strs)) == -1)
	+ return -1;
	+
	+ if (term->_arealen != caplen) {
	+ term->_arealen = caplen;
	+ term->_area = realloc(term->_area, term->_arealen);
	+ if (term->_area == NULL)
	+ return -1;
	+ }
	+ memcpy(term->_area, cap, term->_arealen);
	+
	+ cap = term->_area;
	+ len = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ term->name = cap;
	+ cap += len;
	+ len = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ if (len == 0)
	+ term->_alias = NULL;
	+ else {
	+ term->_alias = cap;
	+ cap += len;
	+ }
	+ len = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ if (len == 0)
	+ term->desc = NULL;
	+ else {
	+ term->desc = cap;
	+ cap += len;
	+ }
	+
	+ num = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ if (num != 0) {
	+ num = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ for (; num != 0; num--) {
	+ ind = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ term->flags[ind] = *cap++;
	+ if (flags == 0 && !VALID_BOOLEAN(term->flags[ind]))
	+ term->flags[ind] = 0;
	+ }
	+ }
	+
	+ num = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ if (num != 0) {
	+ num = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ for (; num != 0; num--) {
	+ ind = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ term->nums[ind] = (short)le16dec(cap);
	+ if (flags == 0 && !VALID_NUMERIC(term->nums[ind]))
	+ term->nums[ind] = ABSENT_NUMERIC;
	+ cap += sizeof(uint16_t);
	+ }
	+ }
	+
	+ num = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ if (num != 0) {
	+ num = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ for (; num != 0; num--) {
	+ ind = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ len = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ if (len > 0)
	+ term->strs[ind] = cap;
	+ else if (flags == 0)
	+ term->strs[ind] = ABSENT_STRING;
	+ else
	+ term->strs[ind] = CANCELLED_STRING;
	+ cap += len;
	+ }
	+ }
	+
	+ num = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ if (num != 0) {
	+ num = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ if (num != term->_nuserdefs) {
	+ free(term->_userdefs);
	+ term->_userdefs = NULL;
	+ term->_nuserdefs = num;
	+ }
	+ if (allocset(&term->_userdefs, 0, term->_nuserdefs,
	+ sizeof(*term->_userdefs)) == -1)
	+ return -1;
	+ for (num = 0; num < term->_nuserdefs; num++) {
	+ ud = &term->_userdefs[num];
	+ len = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ ud->id = cap;
	+ cap += len;
	+ ud->type = *cap++;
	+ switch (ud->type) {
	+ case 'f':
	+ ud->flag = *cap++;
	+ if (flags == 0 &&
	+ !VALID_BOOLEAN(ud->flag))
	+ ud->flag = 0;
	+ ud->num = ABSENT_NUMERIC;
	+ ud->str = ABSENT_STRING;
	+ break;
	+ case 'n':
	+ ud->flag = ABSENT_BOOLEAN;
	+ ud->num = (short)le16dec(cap);
	+ if (flags == 0 &&
	+ !VALID_NUMERIC(ud->num))
	+ ud->num = ABSENT_NUMERIC;
	+ ud->str = ABSENT_STRING;
	+ cap += sizeof(uint16_t);
	+ break;
	+ case 's':
	+ ud->flag = ABSENT_BOOLEAN;
	+ ud->num = ABSENT_NUMERIC;
	+ len = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ if (len > 0)
	+ ud->str = cap;
	+ else if (flags == 0)
	+ ud->str = ABSENT_STRING;
	+ else
	+ ud->str = CANCELLED_STRING;
	+ cap += len;
	+ break;
	+ default:
	+ goto out;
	+ }
	+ }
	+ } else {
	+ term->_nuserdefs = 0;
	+ if (term->_userdefs) {
	+ free(term->_userdefs);
	+ term->_userdefs = NULL;
	+ }
	+ }
	+
	+ return 1;
	+out:
	+ errno = EINVAL;
	+ return -1;
	+}
	+
	+static int
	+_ti_checkname(const char name, const char termname, const char *termalias)
	+{
	+ const char alias, s;
	+ size_t len, l;
	+
	+ /* Check terminal name matches. */
	+ if (strcmp(termname, name) == 0)
	+ return 1;
	+
	+ /* Check terminal aliases match. */
	+ if (termalias == NULL)
	+ return 0;
	+
	+ len = strlen(name);
	+ alias = termalias;
	+ while (*alias != '\0') {
	+ s = strchr(alias, '\|');
	+ if (s == NULL)
	+ l = strlen(alias);
	+ else
	+ l = (size_t)(s - alias);
	+ if (len == l && memcmp(alias, name, l) == 0)
	+ return 1;
	+ if (s == NULL)
	+ break;
	+ alias = s + 1;
	+ }
	+
	+ /* No match. */
	+ return 0;
	+}
	+
	+static int
	+_ti_dbgetterm(TERMINAL term, const char path, const char *name, int flags)
	+{
	+ struct cdbr *db;
	+ const void *data;
	+ const uint8_t *data8;
	+ size_t len, klen;
	+ int r;
	+
	+ r = snprintf(__ti_database, sizeof(__ti_database), "%s.cdb", path);
	+ if (r < 0 \|\| (size_t)r > sizeof(__ti_database)) {
	+ db = NULL;
	+ errno = ENOENT; /* To fall back to a non extension. */
	+ } else
	+ db = cdbr_open(__ti_database, CDBR_DEFAULT);
	+
	+ /* Target file may be a cdb file without the extension. */
	+ if (db == NULL && errno == ENOENT) {
	+ len = strlcpy(__ti_database, path, sizeof(__ti_database));
	+ if (len < sizeof(__ti_database))
	+ db = cdbr_open(__ti_database, CDBR_DEFAULT);
	+ }
	+ if (db == NULL)
	+ return -1;
	+
	+ r = 0;
	+ klen = strlen(name) + 1;
	+ if (cdbr_find(db, name, klen, &data, &len) == -1)
	+ goto out;
	+ data8 = data;
	+ if (len == 0)
	+ goto out;
	+
	+ /* If the entry is an alias, load the indexed terminfo description. */
	+ if (data8[0] == 2) {
	+ if (cdbr_get(db, le32dec(data8 + 1), &data, &len))
	+ goto out;
	+ data8 = data;
	+ }
	+
	+ r = _ti_readterm(term, data, len, flags);
	+ /* Ensure that this is the right terminfo description. */
	+ if (r == 1)
	+ r = _ti_checkname(name, term->name, term->_alias);
	+ /* Remember the database we read. */
	+ if (r == 1)
	+ _ti_database = __ti_database;
	+
	+out:
	+ cdbr_close(db);
	+ return r;
	+}
	+
	+static int
	+_ti_dbgettermp(TERMINAL term, const char path, const char *name, int flags)
	+{
	+ const char *p;
	+ char pathbuf[PATH_MAX];
	+ size_t l;
	+ int r, e;
	+
	+ e = -1;
	+ r = 0;
	+ do {
	+ for (p = path; path != '\0' && path != ':'; path++)
	+ continue;
	+ l = (size_t)(path - p);
	+ if (l != 0 && l + 1 < sizeof(pathbuf)) {
	+ memcpy(pathbuf, p, l);
	+ pathbuf[l] = '\0';
	+ r = _ti_dbgetterm(term, pathbuf, name, flags);
	+ if (r == 1)
	+ return 1;
	+ if (r == 0)
	+ e = 0;
	+ }
	+ } while (*path++ == ':');
	+ return e;
	+}
	+
	+static int
	+_ti_findterm(TERMINAL term, const char name, int flags)
	+{
	+ int r;
	+ char c, e;
	+
	+ _ti_database = NULL;
	+ r = 0;
	+
	+ if ((e = getenv("TERMINFO")) != NULL && *e != '\0') {
	+ if (e[0] == '/')
	+ return _ti_dbgetterm(term, e, name, flags);
	+ }
	+
	+ c = NULL;
	+ if (e == NULL && (c = getenv("TERMCAP")) != NULL) {
	+ if (c != '\0' && c != '/') {
	+ c = strdup(c);
	+ if (c != NULL) {
	+ e = captoinfo(c);
	+ free(c);
	+ }
	+ }
	+ }
	+
	+ if (e != NULL) {
	+ TIC *tic;
	+
	+ if (c == NULL)
	+ e = strdup(e); /* So we don't destroy env */
	+ if (e == NULL)
	+ tic = NULL;
	+ else {
	+ tic = _ti_compile(e, TIC_WARNING \|
	+ TIC_ALIAS \| TIC_DESCRIPTION \| TIC_EXTRA);
	+ free(e);
	+ }
	+ if (tic != NULL &&
	+ _ti_checkname(name, tic->name, tic->alias) == 1)
	+ {
	+ uint8_t *f;
	+ ssize_t len;
	+
	+ len = _ti_flatten(&f, tic);
	+ if (len != -1) {
	+ r = _ti_readterm(term, (char *)f, (size_t)len,
	+ flags);
	+ free(f);
	+ }
	+ }
	+ _ti_freetic(tic);
	+ if (r == 1) {
	+ if (c == NULL)
	+ _ti_database = "$TERMINFO";
	+ else
	+ _ti_database = "$TERMCAP";
	+ return r;
	+ }
	+ }
	+
	+ if ((e = getenv("TERMINFO_DIRS")) != NULL)
	+ return _ti_dbgettermp(term, e, name, flags);
	+
	+ if ((e = getenv("HOME")) != NULL) {
	+ char homepath[PATH_MAX];
	+
	+ if (snprintf(homepath, sizeof(homepath), "%s/.terminfo", e) > 0)
	+ r = _ti_dbgetterm(term, homepath, name, flags);
	+ }
	+ if (r != 1)
	+ r = _ti_dbgettermp(term, _PATH_TERMINFO, name, flags);
	+
	+ return r;
	+}
	+
	+int
	+_ti_getterm(TERMINAL term, const char name, int flags)
	+{
	+ int r;
	+ size_t i;
	+ const struct compiled_term *t;
	+
	+ r = _ti_findterm(term, name, flags);
	+ if (r == 1)
	+ return r;
	+
	+ for (i = 0; i < __arraycount(compiled_terms); i++) {
	+ t = &compiled_terms[i];
	+ if (strcmp(name, t->name) == 0) {
	+ r = _ti_readterm(term, t->cap, t->caplen, flags);
	+ break;
	+ }
	+ }
	+
	+ return r;
	+}
	Index: contrib/mg/term_private.h
	===================================================================
	--- /dev/null
	+++ contrib/mg/term_private.h
	@@ -0,0 +1,163 @@
	+/* $NetBSD: term_private.h,v 1.11 2013/01/24 10:41:28 roy Exp $ */
	+
	+/*
	+ * Copyright (c) 2009, 2010, 2013 The NetBSD Foundation, Inc.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Roy Marples.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ */
	+
	+#ifndef _TERM_PRIVATE_H_
	+#define _TERM_PRIVATE_H_
	+
	+/* This header should only be used by libterminfo, tic and infocmp. */
	+
	+/* The terminfo database structure is private to us,
	+ * so it's documented here.
	+ * terminfo defines the largest number as 32767 and the largest
	+ * compiled entry as 4093 bytes long.
	+ * Thus, we store all numbers as uint16_t, including string length.
	+ * All strings are prefixed by length, including the null terminator.
	+ * The largest string length we can handle is 65535 bytes,
	+ * including the null terminator.
	+ * The largest capability block we can handle is 65535 bytes.
	+ * This means that we exceed the current terminfo defined limits.
	+ *
	+ * Version 1 capabilities are defined as:
	+ * header byte (always 1)
	+ * name
	+ * description,
	+ * cap length, num flags, index, char,
	+ * cap length, num numbers, index, number,
	+ * cap length, num strings, index, string,
	+ * cap length, num undefined caps, name, type (char), flag, number, string
	+ *
	+ * Version 2 entries are aliases and defined as:
	+ * header byte (always 2)
	+ * 32bit id of the corresponding terminal in the file
	+ * name
	+ *
	+ * The database itself is created using cdbw(3) and the numbers are
	+ * always stored as little endian.
	+ */
	+
	+#include <sys/types.h>
	+
	+#define _TERMINFO
	+
	+/* We use the same ncurses tic macros so that our data is identical
	+ * when a caller uses the long name macros to access te terminfo data
	+ * directly. */
	+#define ABSENT_BOOLEAN ((signed char)-1) /* 255 */
	+#define ABSENT_NUMERIC (-1)
	+#define ABSENT_STRING (char *)0
	+#define CANCELLED_BOOLEAN ((signed char)-2) /* 254 */
	+#define CANCELLED_NUMERIC (-2)
	+#define CANCELLED_STRING (char *)(-1)
	+#define VALID_BOOLEAN(s) ((unsigned char)(s) <= 1) /* reject "-1" */
	+#define VALID_NUMERIC(s) ((s) >= 0)
	+#define VALID_STRING(s) ((s) != CANCELLED_STRING && (s) != ABSENT_STRING)
	+
	+typedef struct {
	+ const char *id;
	+ char type;
	+ char flag;
	+ short num;
	+ const char *str;
	+} TERMUSERDEF;
	+
	+typedef struct {
	+ int fildes;
	+ /* We need to expose these so that the macros work */
	+ const char *name;
	+ const char *desc;
	+ signed char *flags;
	+ short *nums;
	+ const char **strs;
	+ /* Storage area for terminfo data */
	+ char *_area;
	+ size_t _arealen;
	+ size_t _nuserdefs;
	+ TERMUSERDEF *_userdefs;
	+ /* So we don't rely on the global ospeed */
	+ short _ospeed;
	+ /* Output buffer for tparm */
	+ char *_buf;
	+ size_t _buflen;
	+ size_t _bufpos;
	+ /* A-Z static variables for tparm */
	+ long _snums[26];
	+ /* aliases of the terminal, \| separated */
	+ const char *_alias;
	+} TERMINAL;
	+
	+extern const char * _ti_database;
	+
	+ssize_t _ti_flagindex(const char *);
	+ssize_t _ti_numindex(const char *);
	+ssize_t _ti_strindex(const char *);
	+const char * _ti_flagid(ssize_t);
	+const char * _ti_numid(ssize_t);
	+const char * _ti_strid(ssize_t);
	+int _ti_getterm(TERMINAL , const char , int);
	+void _ti_setospeed(TERMINAL *);
	+
	+/* libterminfo can compile terminfo strings too */
	+#define TIC_WARNING (1 << 0)
	+#define TIC_DESCRIPTION (1 << 1)
	+#define TIC_ALIAS (1 << 2)
	+#define TIC_COMMENT (1 << 3)
	+#define TIC_EXTRA (1 << 4)
	+
	+#define UINT16_T_MAX 0xffff
	+
	+typedef struct {
	+ char *buf;
	+ size_t buflen;
	+ size_t bufpos;
	+ size_t entries;
	+} TBUF;
	+
	+typedef struct {
	+ char *name;
	+ char *alias;
	+ char *desc;
	+ TBUF flags;
	+ TBUF nums;
	+ TBUF strs;
	+ TBUF extras;
	+} TIC;
	+
	+char _ti_grow_tbuf(TBUF , size_t);
	+char _ti_get_token(char *, char);
	+char _ti_find_cap(TBUF , char, short);
	+char _ti_find_extra(TBUF , const char *);
	+size_t _ti_store_extra(TIC , int, char , char, char, short,
	+ char *, size_t, int);
	+TIC _ti_compile(char , int);
	+ssize_t _ti_flatten(uint8_t *, const TIC );
	+void _ti_freetic(TIC *);
	+
	+#define TPARM_MAX 9 /* not likely to change */
	+int _ti_parm_analyse(const char , int , int);
	+#endif
	Index: contrib/mg/termcap.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/termcap.c
	@@ -0,0 +1,607 @@
	+/* $NetBSD: termcap.c,v 1.22 2017/05/04 09:42:23 roy Exp $ */
	+
	+/*
	+ * Copyright (c) 2009 The NetBSD Foundation, Inc.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Roy Marples.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ */
	+
	+#include <sys/cdefs.h>
	+
	+#include <ctype.h>
	+#include <errno.h>
	+#include <stdbool.h>
	+#include <stdint.h>
	+#include <string.h>
	+#include <unistd.h>
	+#include <stdio.h>
	+
	+#include "term_private.h"
	+#include "terminfo_term.h"
	+
	+#ifndef __UNCONST
	+#define __UNCONST(a) ((void )(unsigned long)(const void )(a))
	+#endif
	+
	+#ifndef __arraycount
	+#define __arraycount(__x) (sizeof(__x) / sizeof(__x[0]))
	+#endif
	+
	+extern void mi_vector_hash(const void * __restrict, size_t, uint32_t,
	+ uint32_t[3]);
	+
	+#include "termcap_map.c"
	+#include "termcap_hash.c"
	+
	+char *UP;
	+char *BC;
	+
	+/* ARGSUSED */
	+int
	+tgetent(__unused char bp, const char name)
	+{
	+ int errret;
	+ static TERMINAL *last = NULL;
	+
	+ /* Free the old term */
	+ if (cur_term != NULL) {
	+ if (last != NULL && cur_term != last)
	+ del_curterm(last);
	+ last = cur_term;
	+ }
	+ errret = -1;
	+ if (setupterm(name, STDOUT_FILENO, &errret) != 0)
	+ return errret;
	+
	+ if (last == NULL)
	+ last = cur_term;
	+
	+ if (pad_char != NULL)
	+ PC = pad_char[0];
	+ UP = __UNCONST(cursor_up);
	+ BC = __UNCONST(cursor_left);
	+ return 1;
	+}
	+
	+int
	+tgetflag(const char *id2)
	+{
	+ uint32_t ind;
	+ size_t i;
	+ TERMUSERDEF *ud;
	+ const char id[] = { id2[0], id2[0] ? id2[1] : '\0', '\0' };
	+
	+ if (cur_term == NULL)
	+ return 0;
	+
	+ ind = _t_flaghash((const unsigned char *)id, strlen(id));
	+ if (ind < __arraycount(_ti_cap_flagids)) {
	+ if (strcmp(id, _ti_cap_flagids[ind].id) == 0)
	+ return cur_term->flags[_ti_cap_flagids[ind].ti];
	+ }
	+ for (i = 0; i < cur_term->_nuserdefs; i++) {
	+ ud = &cur_term->_userdefs[i];
	+ if (ud->type == 'f' && strcmp(ud->id, id) == 0)
	+ return ud->flag;
	+ }
	+ return 0;
	+}
	+
	+int
	+tgetnum(const char *id2)
	+{
	+ uint32_t ind;
	+ size_t i;
	+ TERMUSERDEF *ud;
	+ const TENTRY *te;
	+ const char id[] = { id2[0], id2[0] ? id2[1] : '\0', '\0' };
	+
	+ if (cur_term == NULL)
	+ return -1;
	+
	+ ind = _t_numhash((const unsigned char *)id, strlen(id));
	+ if (ind < __arraycount(_ti_cap_numids)) {
	+ te = &_ti_cap_numids[ind];
	+ if (strcmp(id, te->id) == 0) {
	+ if (!VALID_NUMERIC(cur_term->nums[te->ti]))
	+ return ABSENT_NUMERIC;
	+ return cur_term->nums[te->ti];
	+ }
	+ }
	+ for (i = 0; i < cur_term->_nuserdefs; i++) {
	+ ud = &cur_term->_userdefs[i];
	+ if (ud->type == 'n' && strcmp(ud->id, id) == 0) {
	+ if (!VALID_NUMERIC(ud->num))
	+ return ABSENT_NUMERIC;
	+ return ud->num;
	+ }
	+ }
	+ return -1;
	+}
	+
	+char *
	+tgetstr(const char id2, char *area)
	+{
	+ uint32_t ind;
	+ size_t i;
	+ TERMUSERDEF *ud;
	+ const char *str;
	+ const char id[] = { id2[0], id2[0] ? id2[1] : '\0', '\0' };
	+
	+ if (cur_term == NULL)
	+ return NULL;
	+
	+ str = NULL;
	+ ind = _t_strhash((const unsigned char *)id, strlen(id));
	+ if (ind < __arraycount(_ti_cap_strids)) {
	+ if (strcmp(id, _ti_cap_strids[ind].id) == 0) {
	+ str = cur_term->strs[_ti_cap_strids[ind].ti];
	+ if (str == NULL)
	+ return NULL;
	+ }
	+ }
	+ if (str != NULL)
	+ for (i = 0; i < cur_term->_nuserdefs; i++) {
	+ ud = &cur_term->_userdefs[i];
	+ if (ud->type == 's' && strcmp(ud->id, id) == 0)
	+ str = ud->str;
	+ }
	+
	+ /* XXX: FXIXME
	+ * We should fix sgr0(me) as it has a slightly different meaning
	+ * for termcap. */
	+
	+ if (str != NULL && area != NULL && *area != NULL) {
	+ char *s;
	+ s = *area;
	+ strcpy(*area, str);
	+ area += strlen(area) + 1;
	+ return s;
	+ }
	+
	+ return __UNCONST(str);
	+}
	+
	+char *
	+tgoto(const char *cm, int destcol, int destline)
	+{
	+
	+ return tiparm(cm, destline, destcol);
	+}
	+
	+static const char *
	+flagname(const char *key)
	+{
	+ uint32_t idx;
	+
	+ idx = _t_flaghash((const unsigned char *)key, strlen(key));
	+ if (idx < __arraycount(_ti_cap_flagids) &&
	+ strcmp(key, _ti_cap_flagids[idx].id) == 0)
	+ return _ti_flagid(_ti_cap_flagids[idx].ti);
	+ return key;
	+}
	+
	+static const char *
	+numname(const char *key)
	+{
	+ uint32_t idx;
	+
	+ idx = _t_numhash((const unsigned char *)key, strlen(key));
	+ if (idx < __arraycount(_ti_cap_numids) &&
	+ strcmp(key, _ti_cap_numids[idx].id) == 0)
	+ return _ti_numid(_ti_cap_numids[idx].ti);
	+ return key;
	+}
	+
	+static const char *
	+strname(const char *key)
	+{
	+ uint32_t idx;
	+
	+ idx = _t_strhash((const unsigned char *)key, strlen(key));
	+ if (idx < __arraycount(_ti_cap_strids) &&
	+ strcmp(key, _ti_cap_strids[idx].id) == 0)
	+ return _ti_strid(_ti_cap_strids[idx].ti);
	+
	+ if (strcmp(key, "tc") == 0)
	+ return "use";
	+
	+ return key;
	+}
	+
	+/* Print a parameter if needed */
	+static size_t
	+printparam(char *dst, char p, bool nop)
	+{
	+ if (*nop) {
	+ *nop = false;
	+ return 0;
	+ }
	+
	+ (dst)++ = '%';
	+ (dst)++ = 'p';
	+ (dst)++ = '0' + p;
	+ return 3;
	+}
	+
	+/* Convert a termcap character into terminfo equivalents */
	+static size_t
	+printchar(char dst, const char src)
	+{
	+ char v;
	+ size_t l;
	+
	+ l = 4;
	+ v = ++(src);
	+ if (v == '\\') {
	+ v = ++(src);
	+ switch (v) {
	+ case '0':
	+ case '1':
	+ case '2':
	+ case '3':
	+ v = 0;
	+ while (isdigit((unsigned char) **src))
	+ v = 8 * v + ((src)++ - '0');
	+ (*src)--;
	+ break;
	+ case '\0':
	+ v = '\\';
	+ break;
	+ }
	+ } else if (v == '^')
	+ v = ++(src) & 0x1f;
	+ (dst)++ = '%';
	+ if (isgraph((unsigned char )v) &&
	+ v != ',' && v != '\'' && v != '\\' && v != ':')
	+ {
	+ (dst)++ = '\'';
	+ (dst)++ = v;
	+ (dst)++ = '\'';
	+ } else {
	+ (dst)++ = '{';
	+ if (v > 99) {
	+ (dst)++ = '0'+ v / 100;
	+ l++;
	+ }
	+ if (v > 9) {
	+ (dst)++ = '0' + ((int) (v / 10)) % 10;
	+ l++;
	+ }
	+ (dst)++ = '0' + v % 10;
	+ (dst)++ = '}';
	+ }
	+ return l;
	+}
	+
	+/* Convert termcap commands into terminfo commands */
	+static const char fmtB[] = "%p0%{10}%/%{16}%*%p0%{10}%m%+";
	+static const char fmtD[] = "%p0%p0%{2}%*%-";
	+static const char fmtIf[] = "%p0%p0%?";
	+static const char fmtThen[] = "%>%t";
	+static const char fmtElse[] = "%+%;";
	+
	+static char *
	+strval(const char *val)
	+{
	+ char info, ip, c, p;
	+ const char ps, pe;
	+ bool nop;
	+ size_t len, l;
	+
	+ len = 1024; /* no single string should be bigger */
	+ info = ip = malloc(len);
	+ if (info == NULL)
	+ return 0;
	+
	+ /* Move the = */
	+ ip++ = val++;
	+
	+ /* Set ps and pe to point to the start and end of the padding */
	+ if (isdigit((unsigned char)*val)) {
	+ for (ps = pe = val;
	+ isdigit((unsigned char)val) \|\| val == '.';
	+ val++)
	+ pe++;
	+ if (val == '') {
	+ val++;
	+ pe++;
	+ }
	+ } else
	+ ps = pe = NULL;
	+
	+ nop = false;
	+ l = 0;
	+ p = 1;
	+ for (; *val != '\0'; val++) {
	+ if (l + 2 > len)
	+ goto elen;
	+ if (*val != '%') {
	+ if (*val == ',') {
	+ if (l + 3 > len)
	+ goto elen;
	+ *ip++ = '\\';
	+ l++;
	+ }
	+ ip++ = val;
	+ l++;
	+ continue;
	+ }
	+ switch (c = *++(val)) {
	+ case 'B':
	+ if (l + sizeof(fmtB) > len)
	+ goto elen;
	+ memcpy(ip, fmtB, sizeof(fmtB) - 1);
	+ /* Replace the embedded parameters with real ones */
	+ ip[2] += p;
	+ ip[19] += p;
	+ ip += sizeof(fmtB) - 1;
	+ l += sizeof(fmtB) - 1;
	+ nop = true;
	+ continue;
	+ case 'D':
	+ if (l + sizeof(fmtD) > len)
	+ goto elen;
	+ memcpy(ip, fmtD, sizeof(fmtD) - 1);
	+ /* Replace the embedded parameters with real ones */
	+ ip[2] += p;
	+ ip[5] += p;
	+ ip += sizeof(fmtD) - 1;
	+ l += sizeof(fmtD) - 1;
	+ nop = true;
	+ continue;
	+ case 'r':
	+ /* non op as switched below */
	+ break;
	+ case '2': /* FALLTHROUGH */
	+ case '3': /* FALLTHROUGH */
	+ case 'd':
	+ if (l + 7 > len)
	+ goto elen;
	+ l += printparam(&ip, p, &nop);
	+ *ip++ = '%';
	+ if (c != 'd') {
	+ *ip++ = c;
	+ l++;
	+ }
	+ *ip++ = 'd';
	+ l += 2;
	+ break;
	+ case '+':
	+ if (l + 13 > len)
	+ goto elen;
	+ l += printparam(&ip, p, &nop);
	+ l += printchar(&ip, &val);
	+ *ip++ = '%';
	+ *ip++ = c;
	+ *ip++ = '%';
	+ *ip++ = 'c';
	+ l += 7;
	+ break;
	+ case '>':
	+ if (l + sizeof(fmtIf) + sizeof(fmtThen) +
	+ sizeof(fmtElse) + (6 * 2) > len)
	+ goto elen;
	+
	+ memcpy(ip, fmtIf, sizeof(fmtIf) - 1);
	+ /* Replace the embedded parameters with real ones */
	+ ip[2] += p;
	+ ip[5] += p;
	+ ip += sizeof(fmtIf) - 1;
	+ l += sizeof(fmtIf) - 1;
	+ l += printchar(&ip, &val);
	+ memcpy(ip, fmtThen, sizeof(fmtThen) - 1);
	+ ip += sizeof(fmtThen) - 1;
	+ l += sizeof(fmtThen) - 1;
	+ l += printchar(&ip, &val);
	+ memcpy(ip, fmtElse, sizeof(fmtElse) - 1);
	+ ip += sizeof(fmtElse) - 1;
	+ l += sizeof(fmtElse) - 1;
	+ l += 16;
	+ nop = true;
	+ continue;
	+ case '.':
	+ if (l + 6 > len)
	+ goto elen;
	+ l += printparam(&ip, p, &nop);
	+ *ip++ = '%';
	+ *ip++ = 'c';
	+ l += 2;
	+ break;
	+ default:
	+ /* Hope it matches a terminfo command. */
	+ *ip++ = '%';
	+ *ip++ = c;
	+ l += 2;
	+ if (c == 'i')
	+ continue;
	+ break;
	+ }
	+ /* Swap p1 and p2 */
	+ p = 3 - p;
	+ }
	+
	+ /* \E\ is valid termcap.
	+ * We need to escape the final \ for terminfo. */
	+ if (l > 2 && info[l - 1] == '\\' &&
	+ (info[l - 2] != '\\' && info[l - 2] != '^'))
	+ {
	+ if (l + 1 > len)
	+ goto elen;
	+ *ip++ = '\\';
	+ }
	+
	+ /* Add our padding at the end. */
	+ if (ps != NULL) {
	+ size_t n = (size_t)(pe - ps);
	+ if (l + n + 4 > len)
	+ goto elen;
	+ *ip++ = '$';
	+ *ip++ = '<';
	+ strncpy(ip, ps, n);
	+ ip += n;
	+ *ip++ = '/';
	+ *ip++ = '>';
	+ }
	+
	+ *ip = '\0';
	+ return info;
	+
	+elen:
	+ free(info);
	+ errno = ENOMEM;
	+ return NULL;
	+}
	+
	+typedef struct {
	+ const char *name;
	+ const char *cap;
	+} DEF_INFO;
	+
	+static DEF_INFO def_infos[] = {
	+ { "bel", "^G" },
	+ { "cr", "^M" },
	+ { "cud1", "^J" },
	+ { "ht", "^I" },
	+ { "ind", "^J" },
	+ { "kbs", "^H" },
	+ { "kcub1", "^H" },
	+ { "kcud1", "^J" },
	+ { "nel", "^M^J" }
	+};
	+
	+char *
	+captoinfo(char *cap)
	+{
	+ char info, ip, token, val, *p, tok[3];
	+ const char *name;
	+ size_t len, lp, nl, vl, rl;
	+ int defs[__arraycount(def_infos)], fv;
	+
	+ len = strlen(cap) * 2;
	+ len += __arraycount(def_infos) * (5 + 4 + 3); /* reserve for defs */
	+ info = ip = malloc(len);
	+ if (info == NULL)
	+ return NULL;
	+
	+ memset(defs, 0, sizeof(defs));
	+ lp = 0;
	+ tok[2] = '\0';
	+ for (token = _ti_get_token(&cap, ':');
	+ token != NULL;
	+ token = _ti_get_token(&cap, ':'))
	+ {
	+ if (token[0] == '\0')
	+ continue;
	+ name = token;
	+ val = p = NULL;
	+ fv = nl = 0;
	+ if (token[1] != '\0') {
	+ tok[0] = token[0];
	+ tok[1] = token[1];
	+ nl = 1;
	+ if (token[2] == '\0') {
	+ name = flagname(tok);
	+ val = NULL;
	+ } else if (token[2] == '#') {
	+ name = numname(tok);
	+ val = token + 2;
	+ } else if (token[2] == '=') {
	+ name = strname(tok);
	+ val = strval(token + 2);
	+ fv = 1;
	+ } else
	+ nl = 0;
	+ }
	+ /* If not matched we may need to convert padding still. */
	+ if (nl == 0) {
	+ p = strchr(name, '=');
	+ if (p != NULL) {
	+ val = strval(p);
	+ *p = '\0';
	+ fv = 1;
	+ }
	+ }
	+
	+ /* See if this sets a default. */
	+ for (nl = 0; nl < __arraycount(def_infos); nl++) {
	+ if (strcmp(name, def_infos[nl].name) == 0) {
	+ defs[nl] = 1;
	+ break;
	+ }
	+ }
	+
	+ nl = strlen(name);
	+ if (val == NULL)
	+ vl = 0;
	+ else
	+ vl = strlen(val);
	+ rl = nl + vl + 3; /* , \0 */
	+
	+ if (lp + rl > len) {
	+ if (rl < 256)
	+ len += 256;
	+ else
	+ len += rl;
	+ p = realloc(info, len);
	+ if (p == NULL) {
	+ if (fv == 1)
	+ free(val);
	+ return NULL;
	+ }
	+ info = p;
	+ }
	+
	+ if (ip != info) {
	+ *ip++ = ',';
	+ *ip++ = ' ';
	+ }
	+
	+ strcpy(ip, name);
	+ ip += nl;
	+ if (val != NULL) {
	+ strcpy(ip, val);
	+ ip += vl;
	+ if (fv == 1)
	+ free(val);
	+ }
	+ }
	+
	+ /* Add any defaults not set above. */
	+ for (nl = 0; nl < __arraycount(def_infos); nl++) {
	+ if (defs[nl] == 0) {
	+ *ip++ = ',';
	+ *ip++ = ' ';
	+ strcpy(ip, def_infos[nl].name);
	+ ip += strlen(def_infos[nl].name);
	+ *ip++ = '=';
	+ strcpy(ip, def_infos[nl].cap);
	+ ip += strlen(def_infos[nl].cap);
	+ }
	+ }
	+
	+ *ip = '\0';
	+ return info;
	+}
	+
	Index: contrib/mg/termcap_hash.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/termcap_hash.c
	@@ -0,0 +1,158 @@
	+/* DO NOT EDIT
	+ * Automatically generated from termcap.c */
	+
	+#include <stdint.h>
	+#include <stdlib.h>
	+
	+#include "term_private.h"
	+
	+static uint32_t
	+_t_flaghash(const void * __restrict key, size_t keylen)
	+{
	+ static const uint8_t g[75] = {
	+ 0x0b, 0x17, 0x00, 0x06, 0x0b, 0x00, 0x23, 0x03, 0x0f, 0x1a,
	+ 0x13, 0x00, 0x04, 0x24, 0x1f, 0x1a, 0x00, 0x00, 0x1e, 0x00,
	+ 0x18, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00,
	+ 0x00, 0x0f, 0x00, 0x12, 0x00, 0x14, 0x00, 0x1e, 0x0c, 0x00,
	+ 0x00, 0x1b, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x19, 0x07,
	+ 0x08, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x00, 0x1b,
	+ 0x00, 0x00, 0x00, 0x00, 0x15, 0x00, 0x00, 0x00, 0x12, 0x1b,
	+ 0x00, 0x16, 0x12, 0x00, 0x03,
	+ };
	+ uint32_t h[3];
	+
	+ mi_vector_hash(key, keylen, 0x00000000U, h);
	+ return (g[h[0] % 75] + g[h[1] % 75]) % 37;
	+}
	+
	+#include <stdlib.h>
	+
	+static uint32_t
	+_t_numhash(const void * __restrict key, size_t keylen)
	+{
	+ static const uint8_t g[67] = {
	+ 0x00, 0x1e, 0x01, 0x16, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00,
	+ 0x00, 0x00, 0x00, 0x03, 0x06, 0x00, 0x00, 0x07, 0x00, 0x0f,
	+ 0x03, 0x1c, 0x0c, 0x00, 0x08, 0x11, 0x10, 0x00, 0x0c, 0x0d,
	+ 0x06, 0x00, 0x06, 0x1b, 0x1d, 0x00, 0x00, 0x00, 0x18, 0x1a,
	+ 0x00, 0x04, 0x00, 0x0e, 0x20, 0x1b, 0x00, 0x00, 0x00, 0x00,
	+ 0x00, 0x00, 0x00, 0x0a, 0x1e, 0x00, 0x00, 0x07, 0x00, 0x00,
	+ 0x19, 0x1e, 0x00, 0x02, 0x00, 0x05, 0x00,
	+ };
	+ uint32_t h[3];
	+
	+ mi_vector_hash(key, keylen, 0x00000005U, h);
	+ return (g[h[0] % 67] + g[h[1] % 67]) % 33;
	+}
	+
	+#include <stdlib.h>
	+
	+static uint32_t
	+_t_strhash(const void * __restrict key, size_t keylen)
	+{
	+ static const uint16_t g[789] = {
	+ 0x0172, 0x0088, 0x0000, 0x013f, 0x00a0, 0x0037, 0x0151, 0x0000,
	+ 0x0151, 0x0000, 0x0000, 0x0000, 0x0000, 0x006a, 0x0000, 0x0082,
	+ 0x0000, 0x0000, 0x00d4, 0x0025, 0x015e, 0x0000, 0x002e, 0x00b1,
	+ 0x0000, 0x0122, 0x00b1, 0x0000, 0x017f, 0x0141, 0x0172, 0x0000,
	+ 0x0000, 0x000a, 0x010c, 0x0185, 0x014f, 0x00c1, 0x0011, 0x0000,
	+ 0x0000, 0x012e, 0x0000, 0x0045, 0x0067, 0x00c4, 0x000d, 0x012e,
	+ 0x0000, 0x0004, 0x0000, 0x005f, 0x016c, 0x00df, 0x0000, 0x0000,
	+ 0x0000, 0x0000, 0x017d, 0x0099, 0x014a, 0x0000, 0x0000, 0x0032,
	+ 0x011e, 0x000a, 0x0000, 0x0037, 0x0057, 0x0065, 0x00d4, 0x00d5,
	+ 0x0000, 0x00c2, 0x00f0, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
	+ 0x0000, 0x0000, 0x00d6, 0x016d, 0x0000, 0x0086, 0x0000, 0x0114,
	+ 0x00ac, 0x0000, 0x0000, 0x00d6, 0x0000, 0x0000, 0x0000, 0x008a,
	+ 0x0000, 0x0000, 0x0000, 0x0000, 0x013c, 0x0000, 0x0042, 0x0000,
	+ 0x002e, 0x0000, 0x0000, 0x013e, 0x0032, 0x0000, 0x0000, 0x0000,
	+ 0x0000, 0x0000, 0x0000, 0x0130, 0x0000, 0x0000, 0x013c, 0x0073,
	+ 0x0000, 0x0095, 0x0000, 0x0000, 0x0000, 0x011e, 0x0012, 0x0000,
	+ 0x0067, 0x002b, 0x0000, 0x0000, 0x0000, 0x00c7, 0x0109, 0x0006,
	+ 0x0000, 0x00ff, 0x00d6, 0x0000, 0x0051, 0x0187, 0x0000, 0x0000,
	+ 0x0114, 0x0000, 0x00b5, 0x00c9, 0x000d, 0x0000, 0x0000, 0x0000,
	+ 0x017c, 0x00b5, 0x0171, 0x0000, 0x003b, 0x0000, 0x0000, 0x0089,
	+ 0x016f, 0x0000, 0x0000, 0x009a, 0x002f, 0x007c, 0x013e, 0x0000,
	+ 0x0000, 0x0000, 0x0000, 0x011b, 0x0000, 0x0000, 0x00d4, 0x0087,
	+ 0x0000, 0x0000, 0x0000, 0x0015, 0x00f3, 0x0000, 0x00c2, 0x0092,
	+ 0x0157, 0x0000, 0x0000, 0x0000, 0x0161, 0x0000, 0x0000, 0x0033,
	+ 0x0000, 0x00ff, 0x0156, 0x0000, 0x001c, 0x0000, 0x0000, 0x0139,
	+ 0x0156, 0x0000, 0x0098, 0x0000, 0x0069, 0x0093, 0x0000, 0x0000,
	+ 0x012b, 0x0000, 0x0000, 0x0168, 0x015b, 0x0075, 0x0000, 0x00c1,
	+ 0x00dd, 0x0000, 0x0038, 0x0000, 0x00e6, 0x0000, 0x0000, 0x0165,
	+ 0x00a7, 0x0000, 0x0022, 0x0000, 0x00a9, 0x0000, 0x006d, 0x0000,
	+ 0x0000, 0x0000, 0x013a, 0x0000, 0x004d, 0x0000, 0x0000, 0x0000,
	+ 0x0000, 0x0103, 0x0006, 0x006b, 0x0000, 0x0000, 0x0000, 0x0000,
	+ 0x0106, 0x0000, 0x0000, 0x0000, 0x00aa, 0x013a, 0x0090, 0x00d8,
	+ 0x0000, 0x0000, 0x016b, 0x0000, 0x002b, 0x0000, 0x0000, 0x0183,
	+ 0x0174, 0x0000, 0x0120, 0x0000, 0x0167, 0x00b0, 0x00b0, 0x0000,
	+ 0x0111, 0x0000, 0x0000, 0x015a, 0x0177, 0x0000, 0x0000, 0x0000,
	+ 0x0102, 0x0158, 0x0000, 0x0098, 0x0028, 0x00fd, 0x0168, 0x0032,
	+ 0x0000, 0x0000, 0x0000, 0x0029, 0x00cd, 0x0000, 0x0000, 0x005c,
	+ 0x0041, 0x0000, 0x0000, 0x015f, 0x0000, 0x0034, 0x017c, 0x00fc,
	+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x00a4, 0x0176,
	+ 0x0000, 0x0000, 0x0140, 0x0000, 0x0164, 0x009c, 0x010e, 0x0000,
	+ 0x0000, 0x0000, 0x00a2, 0x00ad, 0x0000, 0x0170, 0x0000, 0x00f6,
	+ 0x00a3, 0x0000, 0x017f, 0x0053, 0x0183, 0x0000, 0x0000, 0x00e8,
	+ 0x0188, 0x0103, 0x0000, 0x0080, 0x005c, 0x016e, 0x0027, 0x0000,
	+ 0x00b7, 0x0000, 0x0000, 0x0000, 0x0150, 0x0078, 0x0000, 0x0000,
	+ 0x00b7, 0x0000, 0x0000, 0x0038, 0x004b, 0x007b, 0x0000, 0x0000,
	+ 0x00b6, 0x0103, 0x0000, 0x006b, 0x0083, 0x0000, 0x0013, 0x00f3,
	+ 0x0000, 0x0031, 0x00bd, 0x0119, 0x005a, 0x0000, 0x0000, 0x0000,
	+ 0x0000, 0x000a, 0x008a, 0x0000, 0x0000, 0x0000, 0x0010, 0x0000,
	+ 0x0000, 0x0000, 0x0116, 0x0000, 0x00b8, 0x0156, 0x0000, 0x0054,
	+ 0x0000, 0x0000, 0x0092, 0x0000, 0x0000, 0x0000, 0x0000, 0x008b,
	+ 0x0172, 0x0000, 0x0000, 0x0188, 0x0000, 0x005d, 0x0000, 0x0000,
	+ 0x003b, 0x0000, 0x0066, 0x00ff, 0x0000, 0x0000, 0x0000, 0x007c,
	+ 0x0000, 0x00e0, 0x0000, 0x0000, 0x0151, 0x00cc, 0x007d, 0x0000,
	+ 0x015b, 0x000c, 0x00e1, 0x0000, 0x0000, 0x006b, 0x0076, 0x0000,
	+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x010f, 0x00f2, 0x0000,
	+ 0x012f, 0x0107, 0x00b7, 0x0000, 0x00d8, 0x0174, 0x00ea, 0x009d,
	+ 0x006d, 0x0000, 0x0000, 0x00d0, 0x0046, 0x012f, 0x00bd, 0x0000,
	+ 0x0120, 0x00ed, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0042,
	+ 0x00e8, 0x0000, 0x0000, 0x00c7, 0x0136, 0x0000, 0x00e8, 0x0002,
	+ 0x0000, 0x00ce, 0x0000, 0x0000, 0x0000, 0x017a, 0x0004, 0x00f7,
	+ 0x00a2, 0x0000, 0x00da, 0x0046, 0x0037, 0x007f, 0x0000, 0x0000,
	+ 0x0000, 0x0000, 0x0184, 0x0000, 0x0000, 0x012a, 0x0000, 0x0000,
	+ 0x0000, 0x0000, 0x0000, 0x00e3, 0x00b7, 0x0000, 0x0000, 0x0000,
	+ 0x0000, 0x013a, 0x0000, 0x00a6, 0x0000, 0x0065, 0x0000, 0x0000,
	+ 0x0000, 0x00cb, 0x010f, 0x0050, 0x0000, 0x0000, 0x0000, 0x0000,
	+ 0x003a, 0x0140, 0x0000, 0x0107, 0x0095, 0x00f2, 0x0000, 0x0000,
	+ 0x005b, 0x0000, 0x015c, 0x012f, 0x0000, 0x0171, 0x0000, 0x001e,
	+ 0x0000, 0x0000, 0x00be, 0x0000, 0x0000, 0x0113, 0x0000, 0x011e,
	+ 0x0000, 0x000c, 0x0000, 0x00a0, 0x0000, 0x0147, 0x006b, 0x00cb,
	+ 0x0025, 0x00f5, 0x0000, 0x0000, 0x0000, 0x00df, 0x00d9, 0x0000,
	+ 0x00e9, 0x00ab, 0x00f3, 0x0000, 0x0000, 0x0000, 0x00eb, 0x0087,
	+ 0x0000, 0x00cb, 0x0000, 0x0000, 0x0123, 0x0000, 0x0016, 0x0000,
	+ 0x011a, 0x0000, 0x00c8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
	+ 0x011c, 0x0000, 0x0000, 0x0000, 0x0000, 0x0008, 0x0000, 0x0000,
	+ 0x0091, 0x00fb, 0x0000, 0x0000, 0x0000, 0x0165, 0x00bc, 0x0024,
	+ 0x015f, 0x0000, 0x0070, 0x00e1, 0x0000, 0x0000, 0x0175, 0x0048,
	+ 0x00c6, 0x0000, 0x008f, 0x00e2, 0x0176, 0x003f, 0x0000, 0x0000,
	+ 0x0000, 0x0035, 0x0000, 0x0011, 0x009e, 0x0000, 0x00d3, 0x003c,
	+ 0x0000, 0x00b0, 0x003e, 0x0180, 0x0000, 0x0064, 0x00ef, 0x0000,
	+ 0x0000, 0x0145, 0x0000, 0x0000, 0x00cf, 0x0000, 0x00e7, 0x0041,
	+ 0x0000, 0x0000, 0x0000, 0x0000, 0x017c, 0x007e, 0x014d, 0x013b,
	+ 0x0000, 0x0000, 0x0000, 0x0122, 0x0000, 0x0000, 0x0000, 0x0069,
	+ 0x0000, 0x0000, 0x0000, 0x0000, 0x00d5, 0x0187, 0x0137, 0x0000,
	+ 0x00f8, 0x0000, 0x0115, 0x008e, 0x0088, 0x0000, 0x0000, 0x0000,
	+ 0x008f, 0x0000, 0x0000, 0x009d, 0x0068, 0x0139, 0x015b, 0x009c,
	+ 0x0039, 0x0000, 0x00b0, 0x0000, 0x0110, 0x0000, 0x0059, 0x000b,
	+ 0x0000, 0x00d2, 0x0082, 0x0000, 0x0000, 0x0000, 0x0000, 0x005a,
	+ 0x013d, 0x0000, 0x0000, 0x004b, 0x0167, 0x0109, 0x0016, 0x0001,
	+ 0x0000, 0x00e4, 0x0000, 0x013d, 0x0000, 0x0000, 0x004d, 0x0000,
	+ 0x0000, 0x0000, 0x0029, 0x0000, 0x0000, 0x005d, 0x0000, 0x0001,
	+ 0x0000, 0x008d, 0x0000, 0x015c, 0x0000, 0x0000, 0x0000, 0x0000,
	+ 0x0000, 0x00c1, 0x0000, 0x0000, 0x0062, 0x0173, 0x0000, 0x0182,
	+ 0x0000, 0x006c, 0x0000, 0x00f1, 0x0000, 0x00e9, 0x012a, 0x0145,
	+ 0x0000, 0x0158, 0x000c, 0x015b, 0x0000, 0x0000, 0x0143, 0x0000,
	+ 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x00fd,
	+ 0x0142, 0x0070, 0x00e3, 0x0116, 0x0168, 0x0000, 0x0000, 0x00e5,
	+ 0x00f2, 0x0139, 0x0000, 0x0000, 0x0010, 0x0160, 0x0125, 0x0000,
	+ 0x00b3, 0x0158, 0x0062, 0x010a, 0x0000, 0x0000, 0x0000, 0x0000,
	+ 0x0000, 0x016e, 0x0000, 0x0000, 0x0000,
	+ };
	+ uint32_t h[3];
	+
	+ mi_vector_hash(key, keylen, 0x00000002U, h);
	+ return (g[h[0] % 789] + g[h[1] % 789]) % 394;
	+}
	Index: contrib/mg/termcap_map.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/termcap_map.c
	@@ -0,0 +1,510 @@
	+/* $NetBSD: termcap_map.c,v 1.3 2010/09/22 06:10:51 roy Exp $ */
	+
	+/*
	+ * Copyright (c) 2009 The NetBSD Foundation, Inc.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Roy Marples.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ */
	+
	+#include <sys/cdefs.h>
	+
	+typedef struct {
	+ const char id[3];
	+ int ti;
	+} TENTRY;
	+
	+static const TENTRY _ti_cap_flagids[] = {
	+ { "bw", TICODE_bw },
	+ { "am", TICODE_am },
	+ { "ut", TICODE_bce },
	+ { "cc", TICODE_ccc },
	+ { "xs", TICODE_xhp },
	+ { "YA", TICODE_xhpa },
	+ { "YF", TICODE_cpix },
	+ { "YB", TICODE_crxm },
	+ { "xt", TICODE_xt },
	+ { "xn", TICODE_xenl },
	+ { "eo", TICODE_eo },
	+ { "gn", TICODE_gn },
	+ { "hc", TICODE_hc },
	+ { "HC", TICODE_chts },
	+ { "km", TICODE_km },
	+ { "YC", TICODE_daisy },
	+ { "hs", TICODE_hs },
	+ { "hl", TICODE_hls },
	+ { "in", TICODE_in },
	+ { "YG", TICODE_lpix },
	+ { "da", TICODE_da },
	+ { "db", TICODE_db },
	+ { "mi", TICODE_mir },
	+ { "ms", TICODE_msgr },
	+ { "nx", TICODE_nxon },
	+ { "xb", TICODE_xsb },
	+ { "NP", TICODE_npc },
	+ { "ND", TICODE_ndscr },
	+ { "NR", TICODE_nrrmc },
	+ { "os", TICODE_os } ,
	+ { "5i", TICODE_mc5i },
	+ { "YD", TICODE_xvpa },
	+ { "YE", TICODE_sam },
	+ { "es", TICODE_eslok },
	+ { "hz", TICODE_hz },
	+ { "ul", TICODE_ul },
	+ { "xo", TICODE_xon }
	+};
	+
	+static const TENTRY _ti_cap_numids[] = {
	+ { "Yo", TICODE_bitwin },
	+ { "Yp", TICODE_bitype },
	+ { "Ya", TICODE_bufsz },
	+ { "BT", TICODE_btns },
	+ { "co", TICODE_cols },
	+ { "Yc", TICODE_spinh },
	+ { "Yb", TICODE_spinv },
	+ { "it", TICODE_it },
	+ { "lh", TICODE_lh },
	+ { "lw", TICODE_lw },
	+ { "li", TICODE_lines },
	+ { "lm", TICODE_lm },
	+ { "ma", TICODE_ma },
	+ { "sg", TICODE_xmc },
	+ { "Co", TICODE_colors },
	+ { "Yd", TICODE_maddr },
	+ { "Ye", TICODE_mjump },
	+ { "pa", TICODE_pairs },
	+ { "MW", TICODE_wnum },
	+ { "Yf", TICODE_mcs },
	+ { "Yg", TICODE_mls },
	+ { "NC", TICODE_ncv },
	+ { "Nl", TICODE_nlab },
	+ { "Yh", TICODE_npins },
	+ { "Yi", TICODE_orc },
	+ { "Yj", TICODE_orl },
	+ { "Yk", TICODE_orhi },
	+ { "Yl", TICODE_orvi },
	+ { "pb", TICODE_pb },
	+ { "Ym", TICODE_cps },
	+ { "vt", TICODE_vt },
	+ { "Yn", TICODE_widcs },
	+ { "ws", TICODE_wsl }
	+};
	+
	+static const TENTRY _ti_cap_strids[] = {
	+ { "ac", TICODE_acsc },
	+ { "S8", TICODE_scesa },
	+ { "bt", TICODE_cbt },
	+ { "bl", TICODE_bel },
	+ { "Yv", TICODE_bicr },
	+ { "Zz", TICODE_binel },
	+ { "Xy", TICODE_birep },
	+ { "cr", TICODE_cr },
	+ { "ZA", TICODE_cpi },
	+ { "ZB", TICODE_lpi },
	+ { "ZC", TICODE_chr },
	+ { "ZD", TICODE_cvr },
	+ { "cs", TICODE_csr },
	+ { "rP", TICODE_rmp },
	+ { "Zy", TICODE_csnm },
	+ { "ct", TICODE_tbc },
	+ { "MC", TICODE_mgc },
	+ { "cl", TICODE_clear },
	+ { "cb", TICODE_el1 },
	+ { "ce", TICODE_el },
	+ { "cd", TICODE_ed },
	+ { "ci", TICODE_csin },
	+ { "Yw", TICODE_colornm },
	+ { "ch", TICODE_hpa },
	+ { "CC", TICODE_cmdch },
	+ { "cm", TICODE_cup },
	+ { "do", TICODE_cud1 },
	+ { "ho", TICODE_home },
	+ { "vi", TICODE_civis },
	+ { "le", TICODE_cub1 },
	+ { "CM", TICODE_mrcup },
	+ { "ve", TICODE_cnorm },
	+ { "nd", TICODE_cuf1 },
	+ { "ll", TICODE_ll },
	+ { "up", TICODE_cuu1 },
	+ { "vs", TICODE_cvvis },
	+ { "Yx", TICODE_defbi },
	+ { "ZE", TICODE_defc },
	+ { "dc", TICODE_dch1 },
	+ { "dl", TICODE_dl1 },
	+ { "dv", TICODE_devt },
	+ { "DI", TICODE_dial },
	+ { "ds", TICODE_dsl },
	+ { "DK", TICODE_dclk },
	+ { "S1", TICODE_dispc },
	+ { "hd", TICODE_hd },
	+ { "eA", TICODE_enacs },
	+ { "Yy", TICODE_endbi },
	+ { "as", TICODE_smacs },
	+ { "SA", TICODE_smam },
	+ { "mb", TICODE_blink },
	+ { "md", TICODE_bold },
	+ { "ti", TICODE_smcup },
	+ { "dm", TICODE_smdc },
	+ { "mh", TICODE_dim },
	+ { "ZF", TICODE_swidm },
	+ { "ZG", TICODE_sdrfq },
	+ { "Xh", TICODE_ehhlm },
	+ { "im", TICODE_smir },
	+ { "ZH", TICODE_sitm },
	+ { "Xl", TICODE_elhlm },
	+ { "ZI", TICODE_slm },
	+ { "Xo", TICODE_elohlm },
	+ { "ZJ", TICODE_smicm },
	+ { "ZK", TICODE_snlq },
	+ { "ZL", TICODE_snrmq },
	+ { "S2", TICODE_smpch },
	+ { "mp", TICODE_prot },
	+ { "mr", TICODE_rev },
	+ { "Xr", TICODE_erhlm },
	+ { "S4", TICODE_smsc },
	+ { "mk", TICODE_invis },
	+ { "ZM", TICODE_sshm },
	+ { "so", TICODE_smso },
	+ { "ZN", TICODE_ssubm },
	+ { "ZO", TICODE_ssupm },
	+ { "Xt", TICODE_ethlm },
	+ { "us", TICODE_smul },
	+ { "ZP", TICODE_sum },
	+ { "Xv", TICODE_evhlm },
	+ { "SX", TICODE_smxon },
	+ { "ec", TICODE_ech },
	+ { "ae", TICODE_rmacs },
	+ { "RA", TICODE_rmam },
	+ { "me", TICODE_sgr0 },
	+ { "te", TICODE_rmcup },
	+ { "ed", TICODE_rmdc },
	+ { "ZQ", TICODE_rwidm },
	+ { "ei", TICODE_rmir },
	+ { "ZR", TICODE_ritm },
	+ { "ZS", TICODE_rlm },
	+ { "ZT", TICODE_rmicm },
	+ { "S3", TICODE_rmpch },
	+ { "S5", TICODE_rmsc },
	+ { "ZU", TICODE_rshm },
	+ { "se", TICODE_rmso },
	+ { "ZV", TICODE_rsubm },
	+ { "ZW", TICODE_rsupm },
	+ { "ue", TICODE_rmul },
	+ { "ZX", TICODE_rum },
	+ { "RX", TICODE_rmxon },
	+ { "PA", TICODE_pause },
	+ { "fh", TICODE_hook },
	+ { "vb", TICODE_flash },
	+ { "ff", TICODE_ff },
	+ { "fs", TICODE_fsl },
	+ { "Gm", TICODE_getm },
	+ { "WG", TICODE_wingo },
	+ { "HU", TICODE_hup },
	+ { "i1", TICODE_is1 },
	+ { "i2", TICODE_is2 },
	+ { "i3", TICODE_is3 },
	+ { "is", TICODE_is2 },
	+ { "if", TICODE_if },
	+ { "iP", TICODE_iprog },
	+ { "Ic", TICODE_initc },
	+ { "Ip", TICODE_initp },
	+ { "ic", TICODE_ich1 },
	+ { "al", TICODE_il1 },
	+ { "ip", TICODE_ip },
	+ { "K1", TICODE_ka1 },
	+ { "K3", TICODE_ka3 },
	+ { "K2", TICODE_kb2 },
	+ { "kb", TICODE_kbs },
	+ { "kB", TICODE_kcbt },
	+ { "K4", TICODE_kc1 },
	+ { "K5", TICODE_kc3 },
	+ { "ka", TICODE_ktbc },
	+ { "kC", TICODE_kclr },
	+ { "kt", TICODE_kctab },
	+ { "kD", TICODE_kdch1 },
	+ { "kL", TICODE_kdl1 },
	+ { "kd", TICODE_kcud1 },
	+ { "kM", TICODE_krmir },
	+ { "kE", TICODE_kel },
	+ { "kS", TICODE_ked },
	+ { "k0", TICODE_kf0 },
	+ { "k1", TICODE_kf1 },
	+ { "k2", TICODE_kf2 },
	+ { "k3", TICODE_kf3 },
	+ { "k4", TICODE_kf4 },
	+ { "k5", TICODE_kf5 },
	+ { "k6", TICODE_kf6 },
	+ { "k7", TICODE_kf7 },
	+ { "k8", TICODE_kf8 },
	+ { "k9", TICODE_kf9 },
	+ { "k;", TICODE_kf10 },
	+ { "F1", TICODE_kf11 },
	+ { "F2", TICODE_kf12 },
	+ { "F3", TICODE_kf13 },
	+ { "F4", TICODE_kf14 },
	+ { "F5", TICODE_kf15 },
	+ { "F6", TICODE_kf16 },
	+ { "F7", TICODE_kf17 },
	+ { "F8", TICODE_kf18 },
	+ { "F9", TICODE_kf19 },
	+ { "FA", TICODE_kf20 },
	+ { "FB", TICODE_kf21 },
	+ { "FC", TICODE_kf22 },
	+ { "FD", TICODE_kf23 },
	+ { "FE", TICODE_kf24 },
	+ { "FF", TICODE_kf25 },
	+ { "FG", TICODE_kf26 },
	+ { "FH", TICODE_kf27 },
	+ { "FI", TICODE_kf28 },
	+ { "FJ", TICODE_kf29 },
	+ { "FK", TICODE_kf30 },
	+ { "FL", TICODE_kf31 },
	+ { "FM", TICODE_kf32 },
	+ { "FN", TICODE_kf33 },
	+ { "FO", TICODE_kf34 },
	+ { "FP", TICODE_kf35 },
	+ { "FQ", TICODE_kf36 },
	+ { "FR", TICODE_kf37 },
	+ { "FS", TICODE_kf38 },
	+ { "FT", TICODE_kf39 },
	+ { "FU", TICODE_kf40 },
	+ { "FV", TICODE_kf41 },
	+ { "FW", TICODE_kf42 },
	+ { "FX", TICODE_kf43 },
	+ { "FY", TICODE_kf44 },
	+ { "FZ", TICODE_kf45 },
	+ { "Fa", TICODE_kf46 },
	+ { "Fb", TICODE_kf47 },
	+ { "Fc", TICODE_kf48 },
	+ { "Fd", TICODE_kf49 },
	+ { "Fe", TICODE_kf50 },
	+ { "Ff", TICODE_kf51 },
	+ { "Fg", TICODE_kf52 },
	+ { "Fh", TICODE_kf53 },
	+ { "Fi", TICODE_kf54 },
	+ { "Fj", TICODE_kf55 },
	+ { "Fk", TICODE_kf56 },
	+ { "Fl", TICODE_kf57 },
	+ { "Fm", TICODE_kf58 },
	+ { "Fn", TICODE_kf59 },
	+ { "Fo", TICODE_kf60 },
	+ { "Fp", TICODE_kf61 },
	+ { "Fq", TICODE_kf62 },
	+ { "Fr", TICODE_kf63 },
	+ { "%1", TICODE_khlp },
	+ { "kh", TICODE_khome },
	+ { "kI", TICODE_kich1 },
	+ { "kA", TICODE_kil1 },
	+ { "kl", TICODE_kcub1 },
	+ { "kH", TICODE_kll },
	+ { "%2", TICODE_kmrk },
	+ { "%3", TICODE_kmsg },
	+ { "Km", TICODE_kmous },
	+ { "%4", TICODE_kmov },
	+ { "%5", TICODE_knxt },
	+ { "kN", TICODE_knp },
	+ { "%6", TICODE_kopn },
	+ { "%7", TICODE_kopt },
	+ { "kP", TICODE_kpp },
	+ { "%8", TICODE_kprv },
	+ { "%9", TICODE_kprt },
	+ { "%0", TICODE_krdo },
	+ { "&1", TICODE_kref },
	+ { "&2", TICODE_krfr },
	+ { "&3", TICODE_krpl },
	+ { "&4", TICODE_krst },
	+ { "&5", TICODE_kres },
	+ { "kr", TICODE_kcuf1 },
	+ { "&6", TICODE_ksav },
	+ { "&9", TICODE_kBEG },
	+ { "&0", TICODE_kCAN },
	+ { "*1", TICODE_kCMD },
	+ { "*2", TICODE_kCPY },
	+ { "*3", TICODE_kCRT },
	+ { "*4", TICODE_kDC },
	+ { "*5", TICODE_kDL },
	+ { "*6", TICODE_kslt },
	+ { "*7", TICODE_kEND },
	+ { "*8", TICODE_kEOL },
	+ { "*9", TICODE_kEXT },
	+ { "kF", TICODE_kind },
	+ { "*0", TICODE_kFND },
	+ { "#1", TICODE_kHLP },
	+ { "#2", TICODE_kHOM },
	+ { "#3", TICODE_kIC },
	+ { "#4", TICODE_kLFT },
	+ { "%a", TICODE_kMSG },
	+ { "%b", TICODE_kMOV },
	+ { "%c", TICODE_kNXT },
	+ { "%d", TICODE_kOPT },
	+ { "%e", TICODE_kPRV },
	+ { "%f", TICODE_kPRT },
	+ { "kR", TICODE_kri },
	+ { "%g", TICODE_kRDO },
	+ { "%h", TICODE_kRPL },
	+ { "%i", TICODE_kRIT },
	+ { "%j", TICODE_kRES },
	+ { "!1", TICODE_kSAV },
	+ { "!2", TICODE_kSPD },
	+ { "kT", TICODE_khts },
	+ { "!3", TICODE_kUND },
	+ { "&7", TICODE_kspd },
	+ { "&8", TICODE_kund },
	+ { "ku", TICODE_kcuu1 },
	+ { "ke", TICODE_rmkx },
	+ { "ks", TICODE_smkx },
	+ { "l0", TICODE_lf0 },
	+ { "l1", TICODE_lf1 },
	+ { "l2", TICODE_lf2 },
	+ { "l3", TICODE_lf3 },
	+ { "l4", TICODE_lf4 },
	+ { "l5", TICODE_lf5 },
	+ { "l6", TICODE_lf6 },
	+ { "l7", TICODE_lf7 },
	+ { "l8", TICODE_lf8 },
	+ { "l9", TICODE_lf9 },
	+ { "la", TICODE_lf10 },
	+ { "Lf", TICODE_fln },
	+ { "LF", TICODE_rmln },
	+ { "LO", TICODE_smln },
	+ { "mo", TICODE_rmm },
	+ { "mm", TICODE_smm },
	+ { "ZY", TICODE_mhpa },
	+ { "ZZ", TICODE_mcud1 },
	+ { "Za", TICODE_mcub1 },
	+ { "Zb", TICODE_mcuf1 },
	+ { "Zc", TICODE_mvpa },
	+ { "Zd", TICODE_mcuu1 },
	+ { "Mi", TICODE_minfo },
	+ { "nw", TICODE_nel },
	+ { "Ze", TICODE_porder },
	+ { "oc", TICODE_oc },
	+ { "op", TICODE_op },
	+ { "pc", TICODE_pad },
	+ { "DC", TICODE_dch },
	+ { "DL", TICODE_dl },
	+ { "DO", TICODE_cud },
	+ { "Zf", TICODE_mcud },
	+ { "IC", TICODE_ich },
	+ { "SF", TICODE_indn },
	+ { "AL", TICODE_il },
	+ { "LE", TICODE_cub },
	+ { "Zg", TICODE_mcub },
	+ { "RI", TICODE_cuf },
	+ { "Zh", TICODE_mcuf },
	+ { "SR", TICODE_rin },
	+ { "UP", TICODE_cuu },
	+ { "Zi", TICODE_mcuu },
	+ { "S6", TICODE_pctrm },
	+ { "pk", TICODE_pfkey },
	+ { "pl", TICODE_pfloc },
	+ { "xl", TICODE_pfxl },
	+ { "px", TICODE_pfx },
	+ { "pn", TICODE_pln },
	+ { "ps", TICODE_mc0 },
	+ { "pO", TICODE_mc5p },
	+ { "pf", TICODE_mc4 },
	+ { "po", TICODE_mc5 },
	+ { "PU", TICODE_pulse },
	+ { "QD", TICODE_qdial },
	+ { "RC", TICODE_rmclk },
	+ { "rp", TICODE_rep },
	+ { "RF", TICODE_rfi },
	+ { "RQ", TICODE_reqmp },
	+ { "r1", TICODE_rs1 },
	+ { "r2", TICODE_rs2 },
	+ { "r3", TICODE_rs3 },
	+ { "rf", TICODE_rf },
	+ { "rc", TICODE_rc },
	+ { "cv", TICODE_vpa },
	+ { "sc", TICODE_sc },
	+ { "S7", TICODE_scesc },
	+ { "sf", TICODE_ind },
	+ { "sr", TICODE_ri },
	+ { "Zj", TICODE_scs },
	+ { "s0", TICODE_s0ds },
	+ { "s1", TICODE_s1ds },
	+ { "s2", TICODE_s2ds },
	+ { "s3", TICODE_s3ds },
	+ { "sA", TICODE_sgr1 },
	+ { "AB", TICODE_setab },
	+ { "AF", TICODE_setaf },
	+ { "sa", TICODE_sgr },
	+ { "Sb", TICODE_setb },
	+ { "Zk", TICODE_smgb },
	+ { "Zl", TICODE_smgbp },
	+ { "SC", TICODE_sclk },
	+ { "Yz", TICODE_slines },
	+ { "sL", TICODE_slength },
	+ { "sp", TICODE_scp },
	+ { "Sf", TICODE_setf },
	+ { "ML", TICODE_smgl }, /* We should fallback to TICODE_smglr */
	+ { "Zm", TICODE_smglp },
	+ { "YZ", TICODE_slines },
	+ { "YI", TICODE_slength },
	+ { "MR", TICODE_smgr },
	+ { "Zn", TICODE_smgrp },
	+ { "st", TICODE_hts },
	+ { "MT", TICODE_smgtb },
	+ { "Zo", TICODE_smgt },
	+ { "Zp", TICODE_smgtp },
	+ { "wi", TICODE_wind },
	+ { "Zq", TICODE_sbim },
	+ { "Zr", TICODE_scsd },
	+ { "Zs", TICODE_rbim },
	+ { "Zt", TICODE_rcsd },
	+ { "Zu", TICODE_subcs },
	+ { "Zv", TICODE_supcs },
	+ { "ta", TICODE_ht },
	+ { "Zw", TICODE_docr },
	+ { "ts", TICODE_tsl },
	+ { "TO", TICODE_tone },
	+ { "u0", TICODE_u0 },
	+ { "u1", TICODE_u1 },
	+ { "u2", TICODE_u2 },
	+ { "u3", TICODE_u3 },
	+ { "u4", TICODE_u4 },
	+ { "u5", TICODE_u5 },
	+ { "u6", TICODE_u6 },
	+ { "u7", TICODE_u7 },
	+ { "u8", TICODE_u8 },
	+ { "u9", TICODE_u9 },
	+ { "uc", TICODE_uc },
	+ { "hu", TICODE_hu },
	+ { "WA", TICODE_wait },
	+ { "XF", TICODE_xoffc },
	+ { "XN", TICODE_xonc },
	+ { "Zx", TICODE_zerom },
	+
	+ /* NetBSD extensions */
	+ { "@0", TICODE_kfnd },
	+ { "@1", TICODE_kbeg },
	+ { "@2", TICODE_kcan },
	+ { "@3", TICODE_kclo },
	+ { "@4", TICODE_kcmd },
	+ { "@5", TICODE_kcpy },
	+ { "@6", TICODE_kcrt },
	+ { "@7", TICODE_kend },
	+ { "@8", TICODE_kent },
	+ { "@9", TICODE_kext },
	+};
	Index: contrib/mg/terminfo_term.h
	===================================================================
	--- /dev/null
	+++ contrib/mg/terminfo_term.h
	@@ -0,0 +1,2005 @@
	+/* $NetBSD: term.h,v 1.22 2017/03/23 00:39:06 roy Exp $ */
	+
	+/*
	+ * Copyright (c) 2009, 2010, 2011, 2013 The NetBSD Foundation, Inc.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Roy Marples.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ */
	+
	+#ifndef _TERM_H_
	+#define _TERM_H_
	+
	+#ifndef ERR
	+#define ERR (-1) /* Error return */
	+#define OK (0) /* Success return */
	+#endif
	+
	+/* Define available terminfo flags */
	+enum TIFLAGS {
	+ TICODE_bw,
	+ TICODE_am,
	+ TICODE_bce,
	+ TICODE_ccc,
	+ TICODE_xhp,
	+ TICODE_xhpa,
	+ TICODE_cpix,
	+ TICODE_crxm,
	+ TICODE_xt,
	+ TICODE_xenl,
	+ TICODE_eo,
	+ TICODE_gn,
	+ TICODE_hc,
	+ TICODE_chts,
	+ TICODE_km,
	+ TICODE_daisy,
	+ TICODE_hs,
	+ TICODE_hls,
	+ TICODE_in,
	+ TICODE_lpix,
	+ TICODE_da,
	+ TICODE_db,
	+ TICODE_mir,
	+ TICODE_msgr,
	+ TICODE_nxon,
	+ TICODE_xsb,
	+ TICODE_npc,
	+ TICODE_ndscr,
	+ TICODE_nrrmc,
	+ TICODE_os,
	+ TICODE_mc5i,
	+ TICODE_xvpa,
	+ TICODE_sam,
	+ TICODE_eslok,
	+ TICODE_hz,
	+ TICODE_ul,
	+ TICODE_xon
	+};
	+#define TIFLAGMAX TICODE_xon
	+
	+#define t_auto_left_margin(t) (t)->flags[TICODE_bw]
	+#define t_auto_right_margin(t) (t)->flags[TICODE_am]
	+#define t_back_color_erase(t) (t)->flags[TICODE_bce]
	+#define t_can_change(t) (t)->flags[TICODE_ccc]
	+#define t_ceol_standout_glitch(t) (t)->flags[TICODE_xhp]
	+#define t_col_addr_glitch(t) (t)->flags[TICODE_xhpa]
	+#define t_cpi_changes_res(t) (t)->flags[TICODE_cpix]
	+#define t_cr_cancels_micro_mode(t) (t)->flags[TICODE_crxm]
	+#define t_dest_tabs_magic_smso(t) (t)->flags[TICODE_xt]
	+#define t_eat_newline_glitch(t) (t)->flags[TICODE_xenl]
	+#define t_erase_overstrike(t) (t)->flags[TICODE_eo]
	+#define t_generic_type(t) (t)->flags[TICODE_gn]
	+#define t_hard_copy(t) (t)->flags[TICODE_hc]
	+#define t_hard_cursor(t) (t)->flags[TICODE_chts]
	+#define t_has_meta_key(t) (t)->flags[TICODE_km]
	+#define t_has_print_wheel(t) (t)->flags[TICODE_daisy]
	+#define t_has_status_line(t) (t)->flags[TICODE_hs]
	+#define t_hue_light_saturation(t) (t)->flags[TICODE_hls]
	+#define t_insert_null_glitch(t) (t)->flags[TICODE_in]
	+#define t_lpi_changes_yes(t) (t)->flags[TICODE_lpix]
	+#define t_memory_above(t) (t)->flags[TICODE_da]
	+#define t_memory_below(t) (t)->flags[TICODE_db]
	+#define t_move_insert_mode(t) (t)->flags[TICODE_mir]
	+#define t_move_standout_mode(t) (t)->flags[TICODE_msgr]
	+#define t_needs_xon_xoff(t) (t)->flags[TICODE_nxon]
	+#define t_no_esc_ctlc(t) (t)->flags[TICODE_xsb]
	+#define t_no_pad_char(t) (t)->flags[TICODE_npc]
	+#define t_non_dest_scroll_region(t) (t)->flags[TICODE_ndscr]
	+#define t_non_rev_rmcup(t) (t)->flags[TICODE_nrrmc]
	+#define t_over_strike(t) (t)->flags[TICODE_os]
	+#define t_prtr_silent(t) (t)->flags[TICODE_mc5i]
	+#define t_row_addr_glitch(t) (t)->flags[TICODE_xvpa]
	+#define t_semi_auto_right_margin(t) (t)->flags[TICODE_sam]
	+#define t_status_line_esc_ok(t) (t)->flags[TICODE_eslok]
	+#define t_tilde_glitch(t) (t)->flags[TICODE_hz]
	+#define t_transparent_underline(t) (t)->flags[TICODE_ul]
	+#define t_xon_xoff(t) (t)->flags[TICODE_xon]
	+
	+#define auto_left_margin t_auto_left_margin(cur_term)
	+#define auto_right_margin t_auto_right_margin(cur_term)
	+#define back_color_erase t_back_color_erase(cur_term)
	+#define can_change t_can_change(cur_term)
	+#define ceol_standout_glitch t_ceol_standout_glitch(cur_term)
	+#define col_addr_glitch t_col_addr_glitch(cur_term)
	+#define cpi_changes_res t_cpi_changes_res(cur_term)
	+#define cr_cancels_micro_mode t_cr_cancels_micro_mode(cur_term)
	+#define dest_tabs_magic_smso t_dest_tabs_magic_smso(cur_term)
	+#define eat_newline_glitch t_eat_newline_glitch(cur_term)
	+#define erase_overstrike t_erase_overstrike(cur_term)
	+#define generic_type t_generic_type(cur_term)
	+#define hard_copy t_hard_copy(cur_term)
	+#define hard_cursor t_hard_cursor(cur_term)
	+#define has_meta_key t_has_meta_key(cur_term)
	+#define has_print_wheel t_has_print_wheel(cur_term)
	+#define has_status_line t_has_status_line(cur_term)
	+#define hue_light_saturation t_hue_light_saturation(cur_term)
	+#define insert_null_glitch t_insert_null_glitch(cur_term)
	+#define lpi_changes_yes t_lpi_changes_yes(cur_term)
	+#define memory_above t_memory_above(cur_term)
	+#define memory_below t_memory_below(cur_term)
	+#define move_insert_mode t_move_insert_mode(cur_term)
	+#define move_standout_mode t_move_standout_mode(cur_term)
	+#define needs_xon_xoff t_needs_xon_xoff(cur_term)
	+#define no_esc_ctlc t_no_esc_ctlc(cur_term)
	+#define no_pad_char t_no_pad_char(cur_term)
	+#define non_dest_scroll_region t_non_dest_scroll_region(cur_term)
	+#define non_rev_rmcup t_non_rev_rmcup(cur_term)
	+#define over_strike t_over_strike(cur_term)
	+#define prtr_silent t_prtr_silent(cur_term)
	+#define row_addr_glitch t_row_addr_glitch(cur_term)
	+#define semi_auto_right_margin t_semi_auto_right_margin(cur_term)
	+#define status_line_esc_ok t_status_line_esc_ok(cur_term)
	+#define tilde_glitch t_tilde_glitch(cur_term)
	+#define transparent_underline t_transparent_underline(cur_term)
	+#define xon_xoff t_xon_xoff(cur_term)
	+
	+/*
	+ * BOOLEAN DESCRIPTIONS
	+ *
	+ * auto_left_margin: cub1 wraps from column 0 to last column
	+ * auto_right_margin: Terminal has automatic margins
	+ * back_color_erase: Screen erased with background colour
	+ * can_change: Terminal can re-define existing colour
	+ * ceol_standout_glitch: Standout not erased by overwriting (hp)
	+ * col_addr_glitch: Only positive motion for hpa/mhba caps
	+ * cpi_changes_res: Changing character pitch changes resolution
	+ * cr_cancels_micro_mode: Using cr turns off micro mode
	+ * dest_tabs_magic_smso: Destructive tabs, magic smso char (t1061)
	+ * eat_newline_glitch: Newline ignored after 80 columns (Concept)
	+ * erase_overstrike: Can erase overstrikes with a blank line
	+ * generic_type: Generic line type (e.g. dialup, switch)
	+ * hard_copy: Hardcopy terminal
	+ * hard_cursor: Cursor is hard to see
	+ * has_meta_key: Has a meta key (shift, sets parity bit)
	+ * has_print_wheel: Printer needs operator to change character set
	+ * has_status_line: Has extra "status line"
	+ * hue_light_saturation: Terminal only uses HLS colour notion (Tektronix)
	+ * insert_null_glitch: Insert mode distinguishes nulls
	+ * lpi_changes_yes: Changing line pitch changes resolution
	+ * memory_above: Display may be retained above the screen
	+ * memory_below: Display may be retained below the screen
	+ * move_insert_mode: Safe to move while in insert mode
	+ * move_standout_mode: Safe to move in standout modes
	+ * needs_xon_xoff: Padding won't work, xon/xoff required
	+ * no_esc_ctlc: Beehive (f1=escape, f2=ctrl C)
	+ * no_pad_char: Pad character doesn't exist
	+ * non_dest_scroll_region: Scrolling region is nondestructive
	+ * non_rev_rmcup: smcup does not reverse rmcup
	+ * over_strike: Terminal overstrikes on hard-copy terminal
	+ * prtr_silent: Printer won't echo on screen
	+ * row_addr_glitch: Only positive motion for vpa/mvpa caps
	+ * semi_auto_right_margin: Printing in last column causes cr
	+ * status_line_esc_ok: Escape can be used on the status line
	+ * tilde_glitch: Hazeltine; can't print tilde (~)
	+ * transparent_underline: Underline character overstrikes
	+ * xon_xoff: Terminal uses xon/xoff handshaking
	+*/
	+
	+/* Define available terminfo numbers */
	+enum TINUMS {
	+ TICODE_bitwin,
	+ TICODE_bitype,
	+ TICODE_bufsz,
	+ TICODE_btns,
	+ TICODE_cols,
	+ TICODE_spinh,
	+ TICODE_spinv,
	+ TICODE_it,
	+ TICODE_lh,
	+ TICODE_lw,
	+ TICODE_lines,
	+ TICODE_lm,
	+ TICODE_ma,
	+ TICODE_xmc,
	+ TICODE_colors,
	+ TICODE_maddr,
	+ TICODE_mjump,
	+ TICODE_pairs,
	+ TICODE_wnum,
	+ TICODE_mcs,
	+ TICODE_mls,
	+ TICODE_ncv,
	+ TICODE_nlab,
	+ TICODE_npins,
	+ TICODE_orc,
	+ TICODE_orl,
	+ TICODE_orhi,
	+ TICODE_orvi,
	+ TICODE_pb,
	+ TICODE_cps,
	+ TICODE_vt,
	+ TICODE_widcs,
	+ TICODE_wsl
	+};
	+#define TINUMMAX TICODE_wsl
	+
	+#define t_bit_image_entwining(t) (t)->nums[TICODE_bitwin]
	+#define t_bit_image_type(t) (t)->nums[TICODE_bitype]
	+#define t_buffer_capacity(t) (t)->nums[TICODE_bufsz]
	+#define t_buttons(t) (t)->nums[TICODE_btns]
	+#define t_columns(t) (t)->nums[TICODE_cols]
	+#define t_dot_horz_spacing(t) (t)->nums[TICODE_spinh]
	+#define t_dot_vert_spacing(t) (t)->nums[TICODE_spinv]
	+#define t_init_tabs(t) (t)->nums[TICODE_it]
	+#define t_label_height(t) (t)->nums[TICODE_lh]
	+#define t_label_width(t) (t)->nums[TICODE_lw]
	+#define t_lines(t) (t)->nums[TICODE_lines]
	+#define t_lines_of_memory(t) (t)->nums[TICODE_lm]
	+#define t_max_attributes(t) (t)->nums[TICODE_ma]
	+#define t_magic_cookie_glitch(t) (t)->nums[TICODE_xmc]
	+#define t_max_colors(t) (t)->nums[TICODE_colors]
	+#define t_max_micro_address(t) (t)->nums[TICODE_maddr]
	+#define t_max_micro_jump(t) (t)->nums[TICODE_mjump]
	+#define t_max_pairs(t) (t)->nums[TICODE_pairs]
	+#define t_maximum_windows(t) (t)->nums[TICODE_wnum]
	+#define t_micro_col_size(t) (t)->nums[TICODE_mcs]
	+#define t_micro_line_size(t) (t)->nums[TICODE_mls]
	+#define t_no_color_video(t) (t)->nums[TICODE_ncv]
	+#define t_num_labels(t) (t)->nums[TICODE_nlab]
	+#define t_number_of_pins(t) (t)->nums[TICODE_npins]
	+#define t_output_res_char(t) (t)->nums[TICODE_orc]
	+#define t_output_res_line(t) (t)->nums[TICODE_orl]
	+#define t_output_res_horz_inch(t) (t)->nums[TICODE_orhi]
	+#define t_output_res_vert_inch(t) (t)->nums[TICODE_orvi]
	+#define t_padding_baud_rate(t) (t)->nums[TICODE_pb]
	+#define t_print_rate(t) (t)->nums[TICODE_cps]
	+#define t_virtual_terminal(t) (t)->nums[TICODE_vt]
	+#define t_wide_char_size(t) (t)->nums[TICODE_widcs]
	+#define t_width_status_line(t) (t)->nums[TICODE_wsl]
	+
	+#define bit_image_entwining t_bit_image_entwining(cur_term)
	+#define bit_image_type t_bit_image_type(cur_term)
	+#define buffer_capacity t_buffer_capacity(cur_term)
	+#define buttons t_buttons(cur_term)
	+#define columns t_columns(cur_term)
	+#define dot_horz_spacing t_dot_horz_spacing(cur_term)
	+#define dot_vert_spacing t_dot_vert_spacing(cur_term)
	+#define init_tabs t_init_tabs(cur_term)
	+#define label_height t_label_height(cur_term)
	+#define label_width t_label_width(cur_term)
	+#define lines t_lines(cur_term)
	+#define lines_of_memory t_lines_of_memory(cur_term)
	+#define max_attributes t_max_attributes(cur_term)
	+#define magic_cookie_glitch t_magic_cookie_glitch(cur_term)
	+#define max_colors t_max_colors(cur_term)
	+#define max_micro_address t_max_micro_address(cur_term)
	+#define max_micro_jump t_max_micro_jump(cur_term)
	+#define max_pairs t_max_pairs(cur_term)
	+#define maximum_windows t_maximum_windows(cur_term)
	+#define micro_col_size t_micro_col_size(cur_term)
	+#define micro_line_size t_micro_line_size(cur_term)
	+#define no_color_video t_no_color_video(cur_term)
	+#define num_labels t_num_labels(cur_term)
	+#define number_of_pins t_number_of_pins(cur_term)
	+#define output_res_char t_output_res_char(cur_term)
	+#define output_res_line t_output_res_line(cur_term)
	+#define output_res_horz_inch t_output_res_horz_inch(cur_term)
	+#define output_res_vert_inch t_output_res_vert_inch(cur_term)
	+#define padding_baud_rate t_padding_baud_rate(cur_term)
	+#define print_rate t_print_rate(cur_term)
	+#define virtual_terminal t_virtual_terminal(cur_term)
	+#define wide_char_size t_wide_char_size(cur_term)
	+#define width_status_line t_width_status_line(cur_term)
	+
	+/*
	+ * NUMBER DESCRIPTIONS
	+ *
	+ * bit_image_entwining: Number of passes for each bit-map row
	+ * bit_image_type: Type of bit image device
	+ * buffer_capacity: Number of bytes buffered before printing
	+ * buttons: Number of buttons on the mouse
	+ * columns: Number of columns in a line
	+ * dot_horz_spacing: Spacing of dots horizontally in dots per inch
	+ * dot_vert_spacing: Spacing of pins vertically in pins per inch
	+ * init_tabs: Tabs initially every #1 spaces
	+ * label_height: Number of rows in each label
	+ * label_width: Numbre of columns in each label
	+ * lines: Number of lines on a screen or a page
	+ * lines_of_memory: Lines of memory of > lines; 0 means varies
	+ * max_attributes: Maximum combined video attributes terminal can display
	+ * magic_cookie_glitch: Number of blank characters left by smso or rmso
	+ * max_colors: Maximum number of colours on the screen
	+ * max_micro_address: Maximum value in micro_..._addresss
	+ * max_micro_jump: Maximum value in parm_..._micro
	+ * max_pairs: Maximum number of colour-pairs on the screen
	+ * maximum_windows: Maximum number of definable windows
	+ * micro_col_size: Character step size when in micro mode
	+ * micro_line_size: Line step size when in micro mode
	+ * no_color_video: Video attributes that can't be used with colours
	+ * num_labels: Number of labels on screen (start at 1)
	+ * number_of_pins: Number of pins in print-head
	+ * output_res_char: Horizontal resolution in units per character
	+ * output_res_line: Vertical resolution in units per line
	+ * output_res_horz_inch: Horizontal resolution in units per inch
	+ * output_res_vert_inch: Vertical resolution in units per inch
	+ * padding_baud_rate: Lowest baud rate where padding needed
	+ * print_rate: Print rate in characters per second
	+ * virtual_terminal: Virtual terminal number
	+ * wide_char_size: Character step size when in double-wide mode
	+ * width_status_line: Number of columns in status line
	+ */
	+
	+/* Define available terminfo strings */
	+enum TISTRS{
	+ TICODE_acsc,
	+ TICODE_scesa,
	+ TICODE_cbt,
	+ TICODE_bel,
	+ TICODE_bicr,
	+ TICODE_binel,
	+ TICODE_birep,
	+ TICODE_cr,
	+ TICODE_cpi,
	+ TICODE_lpi,
	+ TICODE_chr,
	+ TICODE_cvr,
	+ TICODE_csr,
	+ TICODE_rmp,
	+ TICODE_csnm,
	+ TICODE_tbc,
	+ TICODE_mgc,
	+ TICODE_clear,
	+ TICODE_el1,
	+ TICODE_el,
	+ TICODE_ed,
	+ TICODE_csin,
	+ TICODE_colornm,
	+ TICODE_hpa,
	+ TICODE_cmdch,
	+ TICODE_cwin,
	+ TICODE_cup,
	+ TICODE_cud1,
	+ TICODE_home,
	+ TICODE_civis,
	+ TICODE_cub1,
	+ TICODE_mrcup,
	+ TICODE_cnorm,
	+ TICODE_cuf1,
	+ TICODE_ll,
	+ TICODE_cuu1,
	+ TICODE_cvvis,
	+ TICODE_defbi,
	+ TICODE_defc,
	+ TICODE_dch1,
	+ TICODE_dl1,
	+ TICODE_devt,
	+ TICODE_dial,
	+ TICODE_dsl,
	+ TICODE_dclk,
	+ TICODE_dispc,
	+ TICODE_hd,
	+ TICODE_enacs,
	+ TICODE_endbi,
	+ TICODE_smacs,
	+ TICODE_smam,
	+ TICODE_blink,
	+ TICODE_bold,
	+ TICODE_smcup,
	+ TICODE_smdc,
	+ TICODE_dim,
	+ TICODE_swidm,
	+ TICODE_sdrfq,
	+ TICODE_ehhlm,
	+ TICODE_smir,
	+ TICODE_sitm,
	+ TICODE_elhlm,
	+ TICODE_slm,
	+ TICODE_elohlm,
	+ TICODE_smicm,
	+ TICODE_snlq,
	+ TICODE_snrmq,
	+ TICODE_smpch,
	+ TICODE_prot,
	+ TICODE_rev,
	+ TICODE_erhlm,
	+ TICODE_smsc,
	+ TICODE_invis,
	+ TICODE_sshm,
	+ TICODE_smso,
	+ TICODE_ssubm,
	+ TICODE_ssupm,
	+ TICODE_ethlm,
	+ TICODE_smul,
	+ TICODE_sum,
	+ TICODE_evhlm,
	+ TICODE_smxon,
	+ TICODE_ech,
	+ TICODE_rmacs,
	+ TICODE_rmam,
	+ TICODE_sgr0,
	+ TICODE_rmcup,
	+ TICODE_rmdc,
	+ TICODE_rwidm,
	+ TICODE_rmir,
	+ TICODE_ritm,
	+ TICODE_rlm,
	+ TICODE_rmicm,
	+ TICODE_rmpch,
	+ TICODE_rmsc,
	+ TICODE_rshm,
	+ TICODE_rmso,
	+ TICODE_rsubm,
	+ TICODE_rsupm,
	+ TICODE_rmul,
	+ TICODE_rum,
	+ TICODE_rmxon,
	+ TICODE_pause,
	+ TICODE_hook,
	+ TICODE_flash,
	+ TICODE_ff,
	+ TICODE_fsl,
	+ TICODE_getm,
	+ TICODE_wingo,
	+ TICODE_hup,
	+ TICODE_is1,
	+ TICODE_is2,
	+ TICODE_is3,
	+ TICODE_if,
	+ TICODE_iprog,
	+ TICODE_initc,
	+ TICODE_initp,
	+ TICODE_ich1,
	+ TICODE_il1,
	+ TICODE_ip,
	+ TICODE_ka1,
	+ TICODE_ka3,
	+ TICODE_kb2,
	+ TICODE_kbs,
	+ TICODE_kbeg,
	+ TICODE_kcbt,
	+ TICODE_kc1,
	+ TICODE_kc3,
	+ TICODE_kcan,
	+ TICODE_ktbc,
	+ TICODE_kclr,
	+ TICODE_kclo,
	+ TICODE_kcmd,
	+ TICODE_kcpy,
	+ TICODE_kcrt,
	+ TICODE_kctab,
	+ TICODE_kdch1,
	+ TICODE_kdl1,
	+ TICODE_kcud1,
	+ TICODE_krmir,
	+ TICODE_kend,
	+ TICODE_kent,
	+ TICODE_kel,
	+ TICODE_ked,
	+ TICODE_kext,
	+ TICODE_kf0,
	+ TICODE_kf1,
	+ TICODE_kf2,
	+ TICODE_kf3,
	+ TICODE_kf4,
	+ TICODE_kf5,
	+ TICODE_kf6,
	+ TICODE_kf7,
	+ TICODE_kf8,
	+ TICODE_kf9,
	+ TICODE_kf10,
	+ TICODE_kf11,
	+ TICODE_kf12,
	+ TICODE_kf13,
	+ TICODE_kf14,
	+ TICODE_kf15,
	+ TICODE_kf16,
	+ TICODE_kf17,
	+ TICODE_kf18,
	+ TICODE_kf19,
	+ TICODE_kf20,
	+ TICODE_kf21,
	+ TICODE_kf22,
	+ TICODE_kf23,
	+ TICODE_kf24,
	+ TICODE_kf25,
	+ TICODE_kf26,
	+ TICODE_kf27,
	+ TICODE_kf28,
	+ TICODE_kf29,
	+ TICODE_kf30,
	+ TICODE_kf31,
	+ TICODE_kf32,
	+ TICODE_kf33,
	+ TICODE_kf34,
	+ TICODE_kf35,
	+ TICODE_kf36,
	+ TICODE_kf37,
	+ TICODE_kf38,
	+ TICODE_kf39,
	+ TICODE_kf40,
	+ TICODE_kf41,
	+ TICODE_kf42,
	+ TICODE_kf43,
	+ TICODE_kf44,
	+ TICODE_kf45,
	+ TICODE_kf46,
	+ TICODE_kf47,
	+ TICODE_kf48,
	+ TICODE_kf49,
	+ TICODE_kf50,
	+ TICODE_kf51,
	+ TICODE_kf52,
	+ TICODE_kf53,
	+ TICODE_kf54,
	+ TICODE_kf55,
	+ TICODE_kf56,
	+ TICODE_kf57,
	+ TICODE_kf58,
	+ TICODE_kf59,
	+ TICODE_kf60,
	+ TICODE_kf61,
	+ TICODE_kf62,
	+ TICODE_kf63,
	+ TICODE_kfnd,
	+ TICODE_khlp,
	+ TICODE_khome,
	+ TICODE_kich1,
	+ TICODE_kil1,
	+ TICODE_kcub1,
	+ TICODE_kll,
	+ TICODE_kmrk,
	+ TICODE_kmsg,
	+ TICODE_kmous,
	+ TICODE_kmov,
	+ TICODE_knxt,
	+ TICODE_knp,
	+ TICODE_kopn,
	+ TICODE_kopt,
	+ TICODE_kpp,
	+ TICODE_kprv,
	+ TICODE_kprt,
	+ TICODE_krdo,
	+ TICODE_kref,
	+ TICODE_krfr,
	+ TICODE_krpl,
	+ TICODE_krst,
	+ TICODE_kres,
	+ TICODE_kcuf1,
	+ TICODE_ksav,
	+ TICODE_kBEG,
	+ TICODE_kCAN,
	+ TICODE_kCMD,
	+ TICODE_kCPY,
	+ TICODE_kCRT,
	+ TICODE_kDC,
	+ TICODE_kDL,
	+ TICODE_kslt,
	+ TICODE_kEND,
	+ TICODE_kEOL,
	+ TICODE_kEXT,
	+ TICODE_kind,
	+ TICODE_kFND,
	+ TICODE_kHLP,
	+ TICODE_kHOM,
	+ TICODE_kIC,
	+ TICODE_kLFT,
	+ TICODE_kMSG,
	+ TICODE_kMOV,
	+ TICODE_kNXT,
	+ TICODE_kOPT,
	+ TICODE_kPRV,
	+ TICODE_kPRT,
	+ TICODE_kri,
	+ TICODE_kRDO,
	+ TICODE_kRPL,
	+ TICODE_kRIT,
	+ TICODE_kRES,
	+ TICODE_kSAV,
	+ TICODE_kSPD,
	+ TICODE_khts,
	+ TICODE_kUND,
	+ TICODE_kspd,
	+ TICODE_kund,
	+ TICODE_kcuu1,
	+ TICODE_rmkx,
	+ TICODE_smkx,
	+ TICODE_lf0,
	+ TICODE_lf1,
	+ TICODE_lf2,
	+ TICODE_lf3,
	+ TICODE_lf4,
	+ TICODE_lf5,
	+ TICODE_lf6,
	+ TICODE_lf7,
	+ TICODE_lf8,
	+ TICODE_lf9,
	+ TICODE_lf10,
	+ TICODE_fln,
	+ TICODE_rmln,
	+ TICODE_smln,
	+ TICODE_rmm,
	+ TICODE_smm,
	+ TICODE_mhpa,
	+ TICODE_mcud1,
	+ TICODE_mcub1,
	+ TICODE_mcuf1,
	+ TICODE_mvpa,
	+ TICODE_mcuu1,
	+ TICODE_minfo,
	+ TICODE_nel,
	+ TICODE_porder,
	+ TICODE_oc,
	+ TICODE_op,
	+ TICODE_pad,
	+ TICODE_dch,
	+ TICODE_dl,
	+ TICODE_cud,
	+ TICODE_mcud,
	+ TICODE_ich,
	+ TICODE_indn,
	+ TICODE_il,
	+ TICODE_cub,
	+ TICODE_mcub,
	+ TICODE_cuf,
	+ TICODE_mcuf,
	+ TICODE_rin,
	+ TICODE_cuu,
	+ TICODE_mcuu,
	+ TICODE_pctrm,
	+ TICODE_pfkey,
	+ TICODE_pfloc,
	+ TICODE_pfxl,
	+ TICODE_pfx,
	+ TICODE_pln,
	+ TICODE_mc0,
	+ TICODE_mc5p,
	+ TICODE_mc4,
	+ TICODE_mc5,
	+ TICODE_pulse,
	+ TICODE_qdial,
	+ TICODE_rmclk,
	+ TICODE_rep,
	+ TICODE_rfi,
	+ TICODE_reqmp,
	+ TICODE_rs1,
	+ TICODE_rs2,
	+ TICODE_rs3,
	+ TICODE_rf,
	+ TICODE_rc,
	+ TICODE_vpa,
	+ TICODE_sc,
	+ TICODE_scesc,
	+ TICODE_ind,
	+ TICODE_ri,
	+ TICODE_scs,
	+ TICODE_s0ds,
	+ TICODE_s1ds,
	+ TICODE_s2ds,
	+ TICODE_s3ds,
	+ TICODE_sgr1,
	+ TICODE_setab,
	+ TICODE_setaf,
	+ TICODE_sgr,
	+ TICODE_setb,
	+ TICODE_smgb,
	+ TICODE_smgbp,
	+ TICODE_sclk,
	+ TICODE_setcolor,
	+ TICODE_scp,
	+ TICODE_setf,
	+ TICODE_smgl,
	+ TICODE_smglp,
	+ TICODE_smglr,
	+ TICODE_slines,
	+ TICODE_slength,
	+ TICODE_smgr,
	+ TICODE_smgrp,
	+ TICODE_hts,
	+ TICODE_smgtb,
	+ TICODE_smgt,
	+ TICODE_smgtp,
	+ TICODE_wind,
	+ TICODE_sbim,
	+ TICODE_scsd,
	+ TICODE_rbim,
	+ TICODE_rcsd,
	+ TICODE_subcs,
	+ TICODE_supcs,
	+ TICODE_ht,
	+ TICODE_docr,
	+ TICODE_tsl,
	+ TICODE_tone,
	+ TICODE_u0,
	+ TICODE_u1,
	+ TICODE_u2,
	+ TICODE_u3,
	+ TICODE_u4,
	+ TICODE_u5,
	+ TICODE_u6,
	+ TICODE_u7,
	+ TICODE_u8,
	+ TICODE_u9,
	+ TICODE_uc,
	+ TICODE_hu,
	+ TICODE_wait,
	+ TICODE_xoffc,
	+ TICODE_xonc,
	+ TICODE_zerom
	+};
	+#define TISTRMAX TICODE_zerom
	+
	+#define t_acs_chars(t) (t)->strs[TICODE_acsc]
	+#define t_alt_scancode_esc(t) (t)->strs[TICODE_scesa]
	+#define t_back_tab(t) (t)->strs[TICODE_cbt]
	+#define t_bell(t) (t)->strs[TICODE_bel]
	+#define t_bit_image_carriage_return(t) (t)->strs[TICODE_bicr]
	+#define t_bit_image_newline(t) (t)->strs[TICODE_binel]
	+#define t_bit_image_repeat(t) (t)->strs[TICODE_birep]
	+#define t_carriage_return(t) (t)->strs[TICODE_cr]
	+#define t_change_char_pitch(t) (t)->strs[TICODE_cpi]
	+#define t_change_line_pitch(t) (t)->strs[TICODE_lpi]
	+#define t_change_res_horz(t) (t)->strs[TICODE_chr]
	+#define t_change_res_vert(t) (t)->strs[TICODE_cvr]
	+#define t_change_scroll_region(t) (t)->strs[TICODE_csr]
	+#define t_char_padding(t) (t)->strs[TICODE_rmp]
	+#define t_char_set_names(t) (t)->strs[TICODE_csnm]
	+#define t_clear_all_tabs(t) (t)->strs[TICODE_tbc]
	+#define t_clear_margins(t) (t)->strs[TICODE_mgc]
	+#define t_clear_screen(t) (t)->strs[TICODE_clear]
	+#define t_clr_bol(t) (t)->strs[TICODE_el1]
	+#define t_clr_eol(t) (t)->strs[TICODE_el]
	+#define t_clr_eos(t) (t)->strs[TICODE_ed]
	+#define t_code_set_init(t) (t)->strs[TICODE_csin]
	+#define t_color_names(t) (t)->strs[TICODE_colornm]
	+#define t_column_address(t) (t)->strs[TICODE_hpa]
	+#define t_command_character(t) (t)->strs[TICODE_cmdch]
	+#define t_create_window(t) (t)->strs[TICODE_cwin]
	+#define t_cursor_address(t) (t)->strs[TICODE_cup]
	+#define t_cursor_down(t) (t)->strs[TICODE_cud1]
	+#define t_cursor_home(t) (t)->strs[TICODE_home]
	+#define t_cursor_invisible(t) (t)->strs[TICODE_civis]
	+#define t_cursor_left(t) (t)->strs[TICODE_cub1]
	+#define t_cursor_mem_address(t) (t)->strs[TICODE_mrcup]
	+#define t_cursor_normal(t) (t)->strs[TICODE_cnorm]
	+#define t_cursor_right(t) (t)->strs[TICODE_cuf1]
	+#define t_cursor_to_ll(t) (t)->strs[TICODE_ll]
	+#define t_cursor_up(t) (t)->strs[TICODE_cuu1]
	+#define t_cursor_visible(t) (t)->strs[TICODE_cvvis]
	+#define t_define_bit_image_region(t) (t)->strs[TICODE_defbi]
	+#define t_define_char(t) (t)->strs[TICODE_defc]
	+#define t_delete_character(t) (t)->strs[TICODE_dch1]
	+#define t_delete_line(t) (t)->strs[TICODE_dl1]
	+#define t_device_type(t) (t)->strs[TICODE_devt]
	+#define t_dial_phone(t) (t)->strs[TICODE_dial]
	+#define t_dis_status_line(t) (t)->strs[TICODE_dsl]
	+#define t_display_clock(t) (t)->strs[TICODE_dclk]
	+#define t_display_pc_char(t) (t)->strs[TICODE_dispc]
	+#define t_down_half_time(t) (t)->strs[TICODE_hd]
	+#define t_ena_acs(t) (t)->strs[TICODE_enacs]
	+#define t_end_bit_image_region(t) (t)->strs[TICODE_endbi]
	+#define t_enter_alt_charset_mode(t) (t)->strs[TICODE_smacs]
	+#define t_enter_am_mode(t) (t)->strs[TICODE_smam]
	+#define t_enter_blink_mode(t) (t)->strs[TICODE_blink]
	+#define t_enter_bold_mode(t) (t)->strs[TICODE_bold]
	+#define t_enter_ca_mode(t) (t)->strs[TICODE_smcup]
	+#define t_enter_delete_mode(t) (t)->strs[TICODE_smdc]
	+#define t_enter_dim_mode(t) (t)->strs[TICODE_dim]
	+#define t_enter_doublewide_mode(t) (t)->strs[TICODE_swidm]
	+#define t_enter_draft_quality(t) (t)->strs[TICODE_sdrfq]
	+#define t_enter_horizontal_hl_mode(t) (t)->strs[TICODE_ehhlm]
	+#define t_enter_insert_mode(t) (t)->strs[TICODE_smir]
	+#define t_enter_italics_mode(t) (t)->strs[TICODE_sitm]
	+#define t_enter_left_hl_mode(t) (t)->strs[TICODE_elhlm]
	+#define t_enter_leftward_mode(t) (t)->strs[TICODE_slm]
	+#define t_enter_low_hl_mode(t) (t)->strs[TICODE_elohlm]
	+#define t_enter_micro_mode(t) (t)->strs[TICODE_smicm]
	+#define t_enter_near_quality_letter(t) (t)->strs[TICODE_snlq]
	+#define t_enter_normal_quality(t) (t)->strs[TICODE_snrmq]
	+#define t_enter_pc_charset_mode(t) (t)->strs[TICODE_smpch]
	+#define t_enter_protected_mode(t) (t)->strs[TICODE_prot]
	+#define t_enter_reverse_mode(t) (t)->strs[TICODE_rev]
	+#define t_enter_right_hl_mode(t) (t)->strs[TICODE_erhlm]
	+#define t_enter_scancode_mode(t) (t)->strs[TICODE_smsc]
	+#define t_enter_secure_mode(t) (t)->strs[TICODE_invis]
	+#define t_enter_shadow_mode(t) (t)->strs[TICODE_sshm]
	+#define t_enter_standout_mode(t) (t)->strs[TICODE_smso]
	+#define t_enter_subscript_mode(t) (t)->strs[TICODE_ssubm]
	+#define t_enter_superscript_mode(t) (t)->strs[TICODE_ssupm]
	+#define t_enter_top_hl_mode(t) (t)->strs[TICODE_ethlm]
	+#define t_enter_underline_mode(t) (t)->strs[TICODE_smul]
	+#define t_enter_upward_mode(t) (t)->strs[TICODE_sum]
	+#define t_enter_vertical_hl_mode(t) (t)->strs[TICODE_evhlm]
	+#define t_enter_xon_mode(t) (t)->strs[TICODE_smxon]
	+#define t_erase_chars(t) (t)->strs[TICODE_ech]
	+#define t_exit_alt_charset_mode(t) (t)->strs[TICODE_rmacs]
	+#define t_exit_am_mode(t) (t)->strs[TICODE_rmam]
	+#define t_exit_attribute_mode(t) (t)->strs[TICODE_sgr0]
	+#define t_exit_ca_mode(t) (t)->strs[TICODE_rmcup]
	+#define t_exit_delete_mode(t) (t)->strs[TICODE_rmdc]
	+#define t_exit_doublewide_mode(t) (t)->strs[TICODE_rwidm]
	+#define t_exit_insert_mode(t) (t)->strs[TICODE_rmir]
	+#define t_exit_italics_mode(t) (t)->strs[TICODE_ritm]
	+#define t_exit_leftward_mode(t) (t)->strs[TICODE_rlm]
	+#define t_exit_micro_mode(t) (t)->strs[TICODE_rmicm]
	+#define t_exit_pc_charset_mode(t) (t)->strs[TICODE_rmpch]
	+#define t_exit_scancode_mode(t) (t)->strs[TICODE_rmsc]
	+#define t_exit_shadow_mode(t) (t)->strs[TICODE_rshm]
	+#define t_exit_standout_mode(t) (t)->strs[TICODE_rmso]
	+#define t_exit_subscript_mode(t) (t)->strs[TICODE_rsubm]
	+#define t_exit_superscript_mode(t) (t)->strs[TICODE_rsupm]
	+#define t_exit_underline_mode(t) (t)->strs[TICODE_rmul]
	+#define t_exit_upward_mode(t) (t)->strs[TICODE_rum]
	+#define t_exit_xon_mode(t) (t)->strs[TICODE_rmxon]
	+#define t_fixed_pause(t) (t)->strs[TICODE_pause]
	+#define t_flash_hook(t) (t)->strs[TICODE_hook]
	+#define t_flash_screen(t) (t)->strs[TICODE_flash]
	+#define t_form_feed(t) (t)->strs[TICODE_ff]
	+#define t_from_status_line(t) (t)->strs[TICODE_fsl]
	+#define t_get_mouse(t) (t)->strs[TICODE_getm]
	+#define t_goto_window(t) (t)->strs[TICODE_wingo]
	+#define t_hangup(t) (t)->strs[TICODE_hup]
	+#define t_init_1string(t) (t)->strs[TICODE_is1]
	+#define t_init_2string(t) (t)->strs[TICODE_is2]
	+#define t_init_3string(t) (t)->strs[TICODE_is3]
	+#define t_init_file(t) (t)->strs[TICODE_if]
	+#define t_init_prog(t) (t)->strs[TICODE_iprog]
	+#define t_initialize_color(t) (t)->strs[TICODE_initc]
	+#define t_initialize_pair(t) (t)->strs[TICODE_initp]
	+#define t_insert_character(t) (t)->strs[TICODE_ich1]
	+#define t_insert_line(t) (t)->strs[TICODE_il1]
	+#define t_insert_padding(t) (t)->strs[TICODE_ip]
	+#define t_key_a1(t) (t)->strs[TICODE_ka1]
	+#define t_key_a3(t) (t)->strs[TICODE_ka3]
	+#define t_key_b2(t) (t)->strs[TICODE_kb2]
	+#define t_key_backspace(t) (t)->strs[TICODE_kbs]
	+#define t_key_beg(t) (t)->strs[TICODE_kbeg]
	+#define t_key_btab(t) (t)->strs[TICODE_kcbt]
	+#define t_key_c1(t) (t)->strs[TICODE_kc1]
	+#define t_key_c3(t) (t)->strs[TICODE_kc3]
	+#define t_key_cancel(t) (t)->strs[TICODE_kcan]
	+#define t_key_catab(t) (t)->strs[TICODE_ktbc]
	+#define t_key_clear(t) (t)->strs[TICODE_kclr]
	+#define t_key_close(t) (t)->strs[TICODE_kclo]
	+#define t_key_command(t) (t)->strs[TICODE_kcmd]
	+#define t_key_copy(t) (t)->strs[TICODE_kcpy]
	+#define t_key_create(t) (t)->strs[TICODE_kcrt]
	+#define t_key_ctab(t) (t)->strs[TICODE_kctab]
	+#define t_key_dc(t) (t)->strs[TICODE_kdch1]
	+#define t_key_dl(t) (t)->strs[TICODE_kdl1]
	+#define t_key_down(t) (t)->strs[TICODE_kcud1]
	+#define t_key_eic(t) (t)->strs[TICODE_krmir]
	+#define t_key_end(t) (t)->strs[TICODE_kend]
	+#define t_key_enter(t) (t)->strs[TICODE_kent]
	+#define t_key_eol(t) (t)->strs[TICODE_kel]
	+#define t_key_eos(t) (t)->strs[TICODE_ked]
	+#define t_key_exit(t) (t)->strs[TICODE_kext]
	+#define t_key_f0(t) (t)->strs[TICODE_kf0]
	+#define t_key_f1(t) (t)->strs[TICODE_kf1]
	+#define t_key_f2(t) (t)->strs[TICODE_kf2]
	+#define t_key_f3(t) (t)->strs[TICODE_kf3]
	+#define t_key_f4(t) (t)->strs[TICODE_kf4]
	+#define t_key_f5(t) (t)->strs[TICODE_kf5]
	+#define t_key_f6(t) (t)->strs[TICODE_kf6]
	+#define t_key_f7(t) (t)->strs[TICODE_kf7]
	+#define t_key_f8(t) (t)->strs[TICODE_kf8]
	+#define t_key_f9(t) (t)->strs[TICODE_kf9]
	+#define t_key_f10(t) (t)->strs[TICODE_kf10]
	+#define t_key_f11(t) (t)->strs[TICODE_kf11]
	+#define t_key_f12(t) (t)->strs[TICODE_kf12]
	+#define t_key_f13(t) (t)->strs[TICODE_kf13]
	+#define t_key_f14(t) (t)->strs[TICODE_kf14]
	+#define t_key_f15(t) (t)->strs[TICODE_kf15]
	+#define t_key_f16(t) (t)->strs[TICODE_kf16]
	+#define t_key_f17(t) (t)->strs[TICODE_kf17]
	+#define t_key_f18(t) (t)->strs[TICODE_kf18]
	+#define t_key_f19(t) (t)->strs[TICODE_kf19]
	+#define t_key_f20(t) (t)->strs[TICODE_kf20]
	+#define t_key_f21(t) (t)->strs[TICODE_kf21]
	+#define t_key_f22(t) (t)->strs[TICODE_kf22]
	+#define t_key_f23(t) (t)->strs[TICODE_kf23]
	+#define t_key_f24(t) (t)->strs[TICODE_kf24]
	+#define t_key_f25(t) (t)->strs[TICODE_kf25]
	+#define t_key_f26(t) (t)->strs[TICODE_kf26]
	+#define t_key_f27(t) (t)->strs[TICODE_kf27]
	+#define t_key_f28(t) (t)->strs[TICODE_kf28]
	+#define t_key_f29(t) (t)->strs[TICODE_kf29]
	+#define t_key_f30(t) (t)->strs[TICODE_kf30]
	+#define t_key_f31(t) (t)->strs[TICODE_kf31]
	+#define t_key_f32(t) (t)->strs[TICODE_kf32]
	+#define t_key_f33(t) (t)->strs[TICODE_kf33]
	+#define t_key_f34(t) (t)->strs[TICODE_kf34]
	+#define t_key_f35(t) (t)->strs[TICODE_kf35]
	+#define t_key_f36(t) (t)->strs[TICODE_kf36]
	+#define t_key_f37(t) (t)->strs[TICODE_kf37]
	+#define t_key_f38(t) (t)->strs[TICODE_kf38]
	+#define t_key_f39(t) (t)->strs[TICODE_kf39]
	+#define t_key_f40(t) (t)->strs[TICODE_kf40]
	+#define t_key_f41(t) (t)->strs[TICODE_kf41]
	+#define t_key_f42(t) (t)->strs[TICODE_kf42]
	+#define t_key_f43(t) (t)->strs[TICODE_kf43]
	+#define t_key_f44(t) (t)->strs[TICODE_kf44]
	+#define t_key_f45(t) (t)->strs[TICODE_kf45]
	+#define t_key_f46(t) (t)->strs[TICODE_kf46]
	+#define t_key_f47(t) (t)->strs[TICODE_kf47]
	+#define t_key_f48(t) (t)->strs[TICODE_kf48]
	+#define t_key_f49(t) (t)->strs[TICODE_kf49]
	+#define t_key_f50(t) (t)->strs[TICODE_kf50]
	+#define t_key_f51(t) (t)->strs[TICODE_kf51]
	+#define t_key_f52(t) (t)->strs[TICODE_kf52]
	+#define t_key_f53(t) (t)->strs[TICODE_kf53]
	+#define t_key_f54(t) (t)->strs[TICODE_kf54]
	+#define t_key_f55(t) (t)->strs[TICODE_kf55]
	+#define t_key_f56(t) (t)->strs[TICODE_kf56]
	+#define t_key_f57(t) (t)->strs[TICODE_kf57]
	+#define t_key_f58(t) (t)->strs[TICODE_kf58]
	+#define t_key_f59(t) (t)->strs[TICODE_kf59]
	+#define t_key_f60(t) (t)->strs[TICODE_kf60]
	+#define t_key_f61(t) (t)->strs[TICODE_kf61]
	+#define t_key_f62(t) (t)->strs[TICODE_kf62]
	+#define t_key_f63(t) (t)->strs[TICODE_kf63]
	+#define t_key_find(t) (t)->strs[TICODE_kfnd]
	+#define t_key_help(t) (t)->strs[TICODE_khlp]
	+#define t_key_home(t) (t)->strs[TICODE_khome]
	+#define t_key_ic(t) (t)->strs[TICODE_kich1]
	+#define t_key_il(t) (t)->strs[TICODE_kil1]
	+#define t_key_left(t) (t)->strs[TICODE_kcub1]
	+#define t_key_ll(t) (t)->strs[TICODE_kll]
	+#define t_key_mark(t) (t)->strs[TICODE_kmrk]
	+#define t_key_message(t) (t)->strs[TICODE_kmsg]
	+#define t_key_mouse(t) (t)->strs[TICODE_kmous]
	+#define t_key_move(t) (t)->strs[TICODE_kmov]
	+#define t_key_next(t) (t)->strs[TICODE_knxt]
	+#define t_key_npage(t) (t)->strs[TICODE_knp]
	+#define t_key_open(t) (t)->strs[TICODE_kopn]
	+#define t_key_options(t) (t)->strs[TICODE_kopt]
	+#define t_key_ppage(t) (t)->strs[TICODE_kpp]
	+#define t_key_previous(t) (t)->strs[TICODE_kprv]
	+#define t_key_print(t) (t)->strs[TICODE_kprt]
	+#define t_key_redo(t) (t)->strs[TICODE_krdo]
	+#define t_key_reference(t) (t)->strs[TICODE_kref]
	+#define t_key_refresh(t) (t)->strs[TICODE_krfr]
	+#define t_key_replace(t) (t)->strs[TICODE_krpl]
	+#define t_key_restart(t) (t)->strs[TICODE_krst]
	+#define t_key_resume(t) (t)->strs[TICODE_kres]
	+#define t_key_right(t) (t)->strs[TICODE_kcuf1]
	+#define t_key_save(t) (t)->strs[TICODE_ksav]
	+#define t_key_sbeg(t) (t)->strs[TICODE_kBEG]
	+#define t_key_scancel(t) (t)->strs[TICODE_kCAN]
	+#define t_key_scommand(t) (t)->strs[TICODE_kCMD]
	+#define t_key_scopy(t) (t)->strs[TICODE_kCPY]
	+#define t_key_screate(t) (t)->strs[TICODE_kCRT]
	+#define t_key_sdc(t) (t)->strs[TICODE_kDC]
	+#define t_key_sdl(t) (t)->strs[TICODE_kDL]
	+#define t_key_select(t) (t)->strs[TICODE_kslt]
	+#define t_key_send(t) (t)->strs[TICODE_kEND]
	+#define t_key_seol(t) (t)->strs[TICODE_kEOL]
	+#define t_key_sexit(t) (t)->strs[TICODE_kEXT]
	+#define t_key_sf(t) (t)->strs[TICODE_kind]
	+#define t_key_sfind(t) (t)->strs[TICODE_kFND]
	+#define t_key_shelp(t) (t)->strs[TICODE_kHLP]
	+#define t_key_shome(t) (t)->strs[TICODE_kHOM]
	+#define t_key_sic(t) (t)->strs[TICODE_kIC]
	+#define t_key_sleft(t) (t)->strs[TICODE_kLFT]
	+#define t_key_smessage(t) (t)->strs[TICODE_kMSG]
	+#define t_key_smove(t) (t)->strs[TICODE_kMOV]
	+#define t_key_snext(t) (t)->strs[TICODE_kNXT]
	+#define t_key_soptions(t) (t)->strs[TICODE_kOPT]
	+#define t_key_sprevious(t) (t)->strs[TICODE_kPRV]
	+#define t_key_sprint(t) (t)->strs[TICODE_kPRT]
	+#define t_key_sr(t) (t)->strs[TICODE_kri]
	+#define t_key_sredo(t) (t)->strs[TICODE_kRDO]
	+#define t_key_sreplace(t) (t)->strs[TICODE_kRPL]
	+#define t_key_sright(t) (t)->strs[TICODE_kRIT]
	+#define t_key_srsume(t) (t)->strs[TICODE_kRES]
	+#define t_key_ssave(t) (t)->strs[TICODE_kSAV]
	+#define t_key_ssuspend(t) (t)->strs[TICODE_kSPD]
	+#define t_key_stab(t) (t)->strs[TICODE_khts]
	+#define t_key_sundo(t) (t)->strs[TICODE_kUND]
	+#define t_key_suspend(t) (t)->strs[TICODE_kspd]
	+#define t_key_undo(t) (t)->strs[TICODE_kund]
	+#define t_key_up(t) (t)->strs[TICODE_kcuu1]
	+#define t_keypad_local(t) (t)->strs[TICODE_rmkx]
	+#define t_keypad_xmit(t) (t)->strs[TICODE_smkx]
	+#define t_lab_f0(t) (t)->strs[TICODE_lf0]
	+#define t_lab_f1(t) (t)->strs[TICODE_lf1]
	+#define t_lab_f2(t) (t)->strs[TICODE_lf2]
	+#define t_lab_f3(t) (t)->strs[TICODE_lf3]
	+#define t_lab_f4(t) (t)->strs[TICODE_lf4]
	+#define t_lab_f5(t) (t)->strs[TICODE_lf5]
	+#define t_lab_f6(t) (t)->strs[TICODE_lf6]
	+#define t_lab_f7(t) (t)->strs[TICODE_lf7]
	+#define t_lab_f8(t) (t)->strs[TICODE_lf8]
	+#define t_lab_f9(t) (t)->strs[TICODE_lf9]
	+#define t_lab_f10(t) (t)->strs[TICODE_lf10]
	+#define t_label_format(t) (t)->strs[TICODE_fln]
	+#define t_label_off(t) (t)->strs[TICODE_rmln]
	+#define t_label_on(t) (t)->strs[TICODE_smln]
	+#define t_meta_off(t) (t)->strs[TICODE_rmm]
	+#define t_meta_on(t) (t)->strs[TICODE_smm]
	+#define t_micro_column_address(t) (t)->strs[TICODE_mhpa]
	+#define t_micro_down(t) (t)->strs[TICODE_mcud1]
	+#define t_micro_left(t) (t)->strs[TICODE_mcub1]
	+#define t_micro_right(t) (t)->strs[TICODE_mcuf1]
	+#define t_micro_row_address(t) (t)->strs[TICODE_mvpa]
	+#define t_micro_up(t) (t)->strs[TICODE_mcuu1]
	+#define t_mouse_info(t) (t)->strs[TICODE_minfo]
	+#define t_newline(t) (t)->strs[TICODE_nel]
	+#define t_order_of_pins(t) (t)->strs[TICODE_porder]
	+#define t_orig_colors(t) (t)->strs[TICODE_oc]
	+#define t_orig_pair(t) (t)->strs[TICODE_op]
	+#define t_pad_char(t) (t)->strs[TICODE_pad]
	+#define t_parm_dch(t) (t)->strs[TICODE_dch]
	+#define t_parm_delete_line(t) (t)->strs[TICODE_dl]
	+#define t_parm_down_cursor(t) (t)->strs[TICODE_cud]
	+#define t_parm_down_micro(t) (t)->strs[TICODE_mcud]
	+#define t_parm_ich(t) (t)->strs[TICODE_ich]
	+#define t_parm_index(t) (t)->strs[TICODE_indn]
	+#define t_parm_insert_line(t) (t)->strs[TICODE_il]
	+#define t_parm_left_cursor(t) (t)->strs[TICODE_cub]
	+#define t_parm_left_micro(t) (t)->strs[TICODE_mcub]
	+#define t_parm_right_cursor(t) (t)->strs[TICODE_cuf]
	+#define t_parm_right_micro(t) (t)->strs[TICODE_mcuf]
	+#define t_parm_rindex(t) (t)->strs[TICODE_rin]
	+#define t_parm_up_cursor(t) (t)->strs[TICODE_cuu]
	+#define t_parm_up_micro(t) (t)->strs[TICODE_mcuu]
	+#define t_pc_term_options(t) (t)->strs[TICODE_pctrm]
	+#define t_pkey_key(t) (t)->strs[TICODE_pfkey]
	+#define t_pkey_local(t) (t)->strs[TICODE_pfloc]
	+#define t_pkey_plab(t) (t)->strs[TICODE_pfxl]
	+#define t_pkey_xmit(t) (t)->strs[TICODE_pfx]
	+#define t_plab_norm(t) (t)->strs[TICODE_pln]
	+#define t_print_screen(t) (t)->strs[TICODE_mc0]
	+#define t_ptr_non(t) (t)->strs[TICODE_mc5p]
	+#define t_ptr_off(t) (t)->strs[TICODE_mc4]
	+#define t_ptr_on(t) (t)->strs[TICODE_mc5]
	+#define t_pulse(t) (t)->strs[TICODE_pulse]
	+#define t_quick_dial(t) (t)->strs[TICODE_qdial]
	+#define t_remove_clock(t) (t)->strs[TICODE_rmclk]
	+#define t_repeat_char(t) (t)->strs[TICODE_rep]
	+#define t_req_for_input(t) (t)->strs[TICODE_rfi]
	+#define t_req_mouse_pos(t) (t)->strs[TICODE_reqmp]
	+#define t_reset_1string(t) (t)->strs[TICODE_rs1]
	+#define t_reset_2string(t) (t)->strs[TICODE_rs2]
	+#define t_reset_3string(t) (t)->strs[TICODE_rs3]
	+#define t_reset_file(t) (t)->strs[TICODE_rf]
	+#define t_restore_cursor(t) (t)->strs[TICODE_rc]
	+#define t_row_address(t) (t)->strs[TICODE_vpa]
	+#define t_save_cursor(t) (t)->strs[TICODE_sc]
	+#define t_scancode_escape(t) (t)->strs[TICODE_scesc]
	+#define t_scroll_forward(t) (t)->strs[TICODE_ind]
	+#define t_scroll_reverse(t) (t)->strs[TICODE_ri]
	+#define t_select_char_set(t) (t)->strs[TICODE_scs]
	+#define t_set0_des_seq(t) (t)->strs[TICODE_s0ds]
	+#define t_set1_des_seq(t) (t)->strs[TICODE_s1ds]
	+#define t_set2_des_seq(t) (t)->strs[TICODE_s2ds]
	+#define t_set3_des_seq(t) (t)->strs[TICODE_s3ds]
	+#define t_set_a_attributes(t) (t)->strs[TICODE_sgr1]
	+#define t_set_a_background(t) (t)->strs[TICODE_setab]
	+#define t_set_a_foreground(t) (t)->strs[TICODE_setaf]
	+#define t_set_attributes(t) (t)->strs[TICODE_sgr]
	+#define t_set_background(t) (t)->strs[TICODE_setb]
	+#define t_set_bottom_margin(t) (t)->strs[TICODE_smgb]
	+#define t_set_bottom_margin_parm(t) (t)->strs[TICODE_smgbp]
	+#define t_set_clock(t) (t)->strs[TICODE_sclk]
	+#define t_set_color_band(t) (t)->strs[TICODE_setcolor]
	+#define t_set_color_pair(t) (t)->strs[TICODE_scp]
	+#define t_set_foreground(t) (t)->strs[TICODE_setf]
	+#define t_set_left_margin(t) (t)->strs[TICODE_smgl]
	+#define t_set_left_margin_parm(t) (t)->strs[TICODE_smglp]
	+#define t_set_lr_margin(t) (t)->strs[TICODE_smglr]
	+#define t_set_page_length(t) (t)->strs[TICODE_slines]
	+#define t_set_pglen_inch(t) (t)->strs[TICODE_slength]
	+#define t_set_right_margin(t) (t)->strs[TICODE_smgr]
	+#define t_set_right_margin_parm(t) (t)->strs[TICODE_smgrp]
	+#define t_set_tab(t) (t)->strs[TICODE_hts]
	+#define t_set_tb_margin(t) (t)->strs[TICODE_smgtb]
	+#define t_set_top_margin(t) (t)->strs[TICODE_smgt]
	+#define t_set_top_margin_parm(t) (t)->strs[TICODE_smgtp]
	+#define t_set_window(t) (t)->strs[TICODE_wind]
	+#define t_start_bit_image(t) (t)->strs[TICODE_sbim]
	+#define t_start_char_set_def(t) (t)->strs[TICODE_scsd]
	+#define t_stop_bit_image(t) (t)->strs[TICODE_rbim]
	+#define t_stop_char_set_def(t) (t)->strs[TICODE_rcsd]
	+#define t_subscript_characters(t) (t)->strs[TICODE_subcs]
	+#define t_superscript_characters(t) (t)->strs[TICODE_supcs]
	+#define t_tab(t) (t)->strs[TICODE_ht]
	+#define t_these_cause_cr(t) (t)->strs[TICODE_docr]
	+#define t_to_status_line(t) (t)->strs[TICODE_tsl]
	+#define t_tone(t) (t)->strs[TICODE_tone]
	+#define t_user0(t) (t)->strs[TICODE_u0]
	+#define t_user1(t) (t)->strs[TICODE_u1]
	+#define t_user2(t) (t)->strs[TICODE_u2]
	+#define t_user3(t) (t)->strs[TICODE_u3]
	+#define t_user4(t) (t)->strs[TICODE_u4]
	+#define t_user5(t) (t)->strs[TICODE_u5]
	+#define t_user6(t) (t)->strs[TICODE_u6]
	+#define t_user7(t) (t)->strs[TICODE_u7]
	+#define t_user8(t) (t)->strs[TICODE_u8]
	+#define t_user9(t) (t)->strs[TICODE_u9]
	+#define t_underline_char(t) (t)->strs[TICODE_uc]
	+#define t_up_half_line(t) (t)->strs[TICODE_hu]
	+#define t_wait_tone(t) (t)->strs[TICODE_wait]
	+#define t_xoff_character(t) (t)->strs[TICODE_xoffc]
	+#define t_xon_character(t) (t)->strs[TICODE_xonc]
	+#define t_zero_motion(t) (t)->strs[TICODE_zerom]
	+
	+#define acs_chars t_acs_chars(cur_term)
	+#define alt_scancode_esc t_alt_scancode_esc(cur_term)
	+#define back_tab t_back_tab(cur_term)
	+#define bell t_bell(cur_term)
	+#define bit_image_carriage_return t_bit_image_carriage_return(cur_term)
	+#define bit_image_newline t_bit_image_newline(cur_term)
	+#define bit_image_repeat t_bit_image_repeat(cur_term)
	+#define carriage_return t_carriage_return(cur_term)
	+#define change_char_pitch t_change_char_pitch(cur_term)
	+#define change_line_pitch t_change_line_pitch(cur_term)
	+#define change_res_horz t_change_res_horz(cur_term)
	+#define change_res_vert t_change_res_vert(cur_term)
	+#define change_scroll_region t_change_scroll_region(cur_term)
	+#define char_padding t_char_padding(cur_term)
	+#define char_set_names t_char_set_names(cur_term)
	+#define clear_all_tabs t_clear_all_tabs(cur_term)
	+#define clear_margins t_clear_margins(cur_term)
	+#define clear_screen t_clear_screen(cur_term)
	+#define clr_bol t_clr_bol(cur_term)
	+#define clr_eol t_clr_eol(cur_term)
	+#define clr_eos t_clr_eos(cur_term)
	+#define code_set_init t_code_set_init(cur_term)
	+#define color_names t_color_names(cur_term)
	+#define column_address t_column_address(cur_term)
	+#define command_character t_command_character(cur_term)
	+#define create_window t_create_window(cur_term)
	+#define cursor_address t_cursor_address(cur_term)
	+#define cursor_down t_cursor_down(cur_term)
	+#define cursor_home t_cursor_home(cur_term)
	+#define cursor_invisible t_cursor_invisible(cur_term)
	+#define cursor_left t_cursor_left(cur_term)
	+#define cursor_mem_address t_cursor_mem_address(cur_term)
	+#define cursor_normal t_cursor_normal(cur_term)
	+#define cursor_right t_cursor_right(cur_term)
	+#define cursor_to_ll t_cursor_to_ll(cur_term)
	+#define cursor_up t_cursor_up(cur_term)
	+#define cursor_visible t_cursor_visible(cur_term)
	+#define define_bit_image_region t_define_bit_image_region(cur_term)
	+#define define_char t_define_char(cur_term)
	+#define delete_character t_delete_character(cur_term)
	+#define delete_line t_delete_line(cur_term)
	+#define device_type t_device_type(cur_term)
	+#define dial_phone t_dial_phone(cur_term)
	+#define dis_status_line t_dis_status_line(cur_term)
	+#define display_clock t_display_clock(cur_term)
	+#define display_pc_char t_display_pc_char(cur_term)
	+#define down_half_time t_down_half_time(cur_term)
	+#define ena_acs t_ena_acs(cur_term)
	+#define end_bit_image_region t_end_bit_image_region(cur_term)
	+#define enter_alt_charset_mode t_enter_alt_charset_mode(cur_term)
	+#define enter_am_mode t_enter_am_mode(cur_term)
	+#define enter_blink_mode t_enter_blink_mode(cur_term)
	+#define enter_bold_mode t_enter_bold_mode(cur_term)
	+#define enter_ca_mode t_enter_ca_mode(cur_term)
	+#define enter_delete_mode t_enter_delete_mode(cur_term)
	+#define enter_dim_mode t_enter_dim_mode(cur_term)
	+#define enter_doublewide_mode t_enter_doublewide_mode(cur_term)
	+#define enter_draft_quality t_enter_draft_quality(cur_term)
	+#define enter_horizontal_hl_mode t_enter_horizontal_hl_mode(cur_term)
	+#define enter_insert_mode t_enter_insert_mode(cur_term)
	+#define enter_italics_mode t_enter_italics_mode(cur_term)
	+#define enter_left_hl_mode t_enter_left_hl_mode(cur_term)
	+#define enter_leftward_mode t_enter_leftward_mode(cur_term)
	+#define enter_low_hl_mode t_enter_low_hl_mode(cur_term)
	+#define enter_micro_mode t_enter_micro_mode(cur_term)
	+#define enter_near_quality_letter t_enter_near_quality_letter(cur_term)
	+#define enter_normal_quality t_enter_normal_quality(cur_term)
	+#define enter_pc_charset_mode t_enter_pc_charset_mode(cur_term)
	+#define enter_protected_mode t_enter_protected_mode(cur_term)
	+#define enter_reverse_mode t_enter_reverse_mode(cur_term)
	+#define enter_right_hl_mode t_enter_right_hl_mode(cur_term)
	+#define enter_scancode_mode t_enter_scancode_mode(cur_term)
	+#define enter_secure_mode t_enter_secure_mode(cur_term)
	+#define enter_shadow_mode t_enter_shadow_mode(cur_term)
	+#define enter_standout_mode t_enter_standout_mode(cur_term)
	+#define enter_subscript_mode t_enter_subscript_mode(cur_term)
	+#define enter_superscript_mode t_enter_superscript_mode(cur_term)
	+#define enter_top_hl_mode t_enter_top_hl_mode(cur_term)
	+#define enter_underline_mode t_enter_underline_mode(cur_term)
	+#define enter_upward_mode t_enter_upward_mode(cur_term)
	+#define enter_vertical_hl_mode t_enter_vertical_hl_mode(cur_term)
	+#define enter_xon_mode t_enter_xon_mode(cur_term)
	+#define erase_chars t_erase_chars(cur_term)
	+#define exit_alt_charset_mode t_exit_alt_charset_mode(cur_term)
	+#define exit_am_mode t_exit_am_mode(cur_term)
	+#define exit_attribute_mode t_exit_attribute_mode(cur_term)
	+#define exit_ca_mode t_exit_ca_mode(cur_term)
	+#define exit_delete_mode t_exit_delete_mode(cur_term)
	+#define exit_doublewide_mode t_exit_doublewide_mode(cur_term)
	+#define exit_insert_mode t_exit_insert_mode(cur_term)
	+#define exit_italics_mode t_exit_italics_mode(cur_term)
	+#define exit_leftward_mode t_exit_leftward_mode(cur_term)
	+#define exit_micro_mode t_exit_micro_mode(cur_term)
	+#define exit_pc_charset_mode t_exit_pc_charset_mode(cur_term)
	+#define exit_scancode_mode t_exit_scancode_mode(cur_term)
	+#define exit_shadow_mode t_exit_shadow_mode(cur_term)
	+#define exit_standout_mode t_exit_standout_mode(cur_term)
	+#define exit_subscript_mode t_exit_subscript_mode(cur_term)
	+#define exit_superscript_mode t_exit_superscript_mode(cur_term)
	+#define exit_underline_mode t_exit_underline_mode(cur_term)
	+#define exit_upward_mode t_exit_upward_mode(cur_term)
	+#define exit_xon_mode t_exit_xon_mode(cur_term)
	+#define fixed_pause t_fixed_pause(cur_term)
	+#define flash_hook t_flash_hook(cur_term)
	+#define flash_screen t_flash_screen(cur_term)
	+#define form_feed t_form_feed(cur_term)
	+#define from_status_line t_from_status_line(cur_term)
	+#define get_mouse t_get_mouse(cur_term)
	+#define goto_window t_goto_window(cur_term)
	+#define hangup t_hangup(cur_term)
	+#define init_1string t_init_1string(cur_term)
	+#define init_2string t_init_2string(cur_term)
	+#define init_3string t_init_3string(cur_term)
	+#define init_file t_init_file(cur_term)
	+#define init_prog t_init_prog(cur_term)
	+#define initialize_color t_initialize_color(cur_term)
	+#define initialize_pair t_initialize_pair(cur_term)
	+#define insert_character t_insert_character(cur_term)
	+#define insert_line t_insert_line(cur_term)
	+#define insert_padding t_insert_padding(cur_term)
	+#define key_a1 t_key_a1(cur_term)
	+#define key_a3 t_key_a3(cur_term)
	+#define key_b2 t_key_b2(cur_term)
	+#define key_backspace t_key_backspace(cur_term)
	+#define key_beg t_key_beg(cur_term)
	+#define key_btab t_key_btab(cur_term)
	+#define key_c1 t_key_c1(cur_term)
	+#define key_c3 t_key_c3(cur_term)
	+#define key_cancel t_key_cancel(cur_term)
	+#define key_catab t_key_catab(cur_term)
	+#define key_clear t_key_clear(cur_term)
	+#define key_close t_key_close(cur_term)
	+#define key_command t_key_command(cur_term)
	+#define key_copy t_key_copy(cur_term)
	+#define key_create t_key_create(cur_term)
	+#define key_ctab t_key_ctab(cur_term)
	+#define key_dc t_key_dc(cur_term)
	+#define key_dl t_key_dl(cur_term)
	+#define key_down t_key_down(cur_term)
	+#define key_eic t_key_eic(cur_term)
	+#define key_end t_key_end(cur_term)
	+#define key_enter t_key_enter(cur_term)
	+#define key_eol t_key_eol(cur_term)
	+#define key_eos t_key_eos(cur_term)
	+#define key_exit t_key_exit(cur_term)
	+#define key_f0 t_key_f0(cur_term)
	+#define key_f1 t_key_f1(cur_term)
	+#define key_f2 t_key_f2(cur_term)
	+#define key_f3 t_key_f3(cur_term)
	+#define key_f4 t_key_f4(cur_term)
	+#define key_f5 t_key_f5(cur_term)
	+#define key_f6 t_key_f6(cur_term)
	+#define key_f7 t_key_f7(cur_term)
	+#define key_f8 t_key_f8(cur_term)
	+#define key_f9 t_key_f9(cur_term)
	+#define key_f10 t_key_f10(cur_term)
	+#define key_f11 t_key_f11(cur_term)
	+#define key_f12 t_key_f12(cur_term)
	+#define key_f13 t_key_f13(cur_term)
	+#define key_f14 t_key_f14(cur_term)
	+#define key_f15 t_key_f15(cur_term)
	+#define key_f16 t_key_f16(cur_term)
	+#define key_f17 t_key_f17(cur_term)
	+#define key_f18 t_key_f18(cur_term)
	+#define key_f19 t_key_f19(cur_term)
	+#define key_f20 t_key_f20(cur_term)
	+#define key_f21 t_key_f21(cur_term)
	+#define key_f22 t_key_f22(cur_term)
	+#define key_f23 t_key_f23(cur_term)
	+#define key_f24 t_key_f24(cur_term)
	+#define key_f25 t_key_f25(cur_term)
	+#define key_f26 t_key_f26(cur_term)
	+#define key_f27 t_key_f27(cur_term)
	+#define key_f28 t_key_f28(cur_term)
	+#define key_f29 t_key_f29(cur_term)
	+#define key_f30 t_key_f30(cur_term)
	+#define key_f31 t_key_f31(cur_term)
	+#define key_f32 t_key_f32(cur_term)
	+#define key_f33 t_key_f33(cur_term)
	+#define key_f34 t_key_f34(cur_term)
	+#define key_f35 t_key_f35(cur_term)
	+#define key_f36 t_key_f36(cur_term)
	+#define key_f37 t_key_f37(cur_term)
	+#define key_f38 t_key_f38(cur_term)
	+#define key_f39 t_key_f39(cur_term)
	+#define key_f40 t_key_f40(cur_term)
	+#define key_f41 t_key_f41(cur_term)
	+#define key_f42 t_key_f42(cur_term)
	+#define key_f43 t_key_f43(cur_term)
	+#define key_f44 t_key_f44(cur_term)
	+#define key_f45 t_key_f45(cur_term)
	+#define key_f46 t_key_f46(cur_term)
	+#define key_f47 t_key_f47(cur_term)
	+#define key_f48 t_key_f48(cur_term)
	+#define key_f49 t_key_f49(cur_term)
	+#define key_f50 t_key_f50(cur_term)
	+#define key_f51 t_key_f51(cur_term)
	+#define key_f52 t_key_f52(cur_term)
	+#define key_f53 t_key_f53(cur_term)
	+#define key_f54 t_key_f54(cur_term)
	+#define key_f55 t_key_f55(cur_term)
	+#define key_f56 t_key_f56(cur_term)
	+#define key_f57 t_key_f57(cur_term)
	+#define key_f58 t_key_f58(cur_term)
	+#define key_f59 t_key_f59(cur_term)
	+#define key_f60 t_key_f60(cur_term)
	+#define key_f61 t_key_f61(cur_term)
	+#define key_f62 t_key_f62(cur_term)
	+#define key_f63 t_key_f63(cur_term)
	+#define key_find t_key_find(cur_term)
	+#define key_help t_key_help(cur_term)
	+#define key_home t_key_home(cur_term)
	+#define key_ic t_key_ic(cur_term)
	+#define key_il t_key_il(cur_term)
	+#define key_left t_key_left(cur_term)
	+#define key_ll t_key_ll(cur_term)
	+#define key_mark t_key_mark(cur_term)
	+#define key_message t_key_message(cur_term)
	+#define key_mouse t_key_mouse(cur_term)
	+#define key_move t_key_move(cur_term)
	+#define key_next t_key_next(cur_term)
	+#define key_npage t_key_npage(cur_term)
	+#define key_open t_key_open(cur_term)
	+#define key_options t_key_options(cur_term)
	+#define key_ppage t_key_ppage(cur_term)
	+#define key_previous t_key_previous(cur_term)
	+#define key_print t_key_print(cur_term)
	+#define key_redo t_key_redo(cur_term)
	+#define key_reference t_key_reference(cur_term)
	+#define key_refresh t_key_refresh(cur_term)
	+#define key_replace t_key_replace(cur_term)
	+#define key_restart t_key_restart(cur_term)
	+#define key_resume t_key_resume(cur_term)
	+#define key_right t_key_right(cur_term)
	+#define key_save t_key_save(cur_term)
	+#define key_sbeg t_key_sbeg(cur_term)
	+#define key_scancel t_key_scancel(cur_term)
	+#define key_scommand t_key_scommand(cur_term)
	+#define key_scopy t_key_scopy(cur_term)
	+#define key_screate t_key_screate(cur_term)
	+#define key_sdc t_key_sdc(cur_term)
	+#define key_sdl t_key_sdl(cur_term)
	+#define key_select t_key_select(cur_term)
	+#define key_send t_key_send(cur_term)
	+#define key_seol t_key_seol(cur_term)
	+#define key_sexit t_key_sexit(cur_term)
	+#define key_sf t_key_sf(cur_term)
	+#define key_sfind t_key_sfind(cur_term)
	+#define key_shelp t_key_shelp(cur_term)
	+#define key_shome t_key_shome(cur_term)
	+#define key_sic t_key_sic(cur_term)
	+#define key_sleft t_key_sleft(cur_term)
	+#define key_smessage t_key_smessage(cur_term)
	+#define key_smove t_key_smove(cur_term)
	+#define key_snext t_key_snext(cur_term)
	+#define key_soptions t_key_soptions(cur_term)
	+#define key_sprevious t_key_sprevious(cur_term)
	+#define key_sprint t_key_sprint(cur_term)
	+#define key_sr t_key_sr(cur_term)
	+#define key_sredo t_key_sredo(cur_term)
	+#define key_sreplace t_key_sreplace(cur_term)
	+#define key_sright t_key_sright(cur_term)
	+#define key_srsume t_key_srsume(cur_term)
	+#define key_ssave t_key_ssave(cur_term)
	+#define key_ssuspend t_key_ssuspend(cur_term)
	+#define key_stab t_key_stab(cur_term)
	+#define key_sundo t_key_sundo(cur_term)
	+#define key_suspend t_key_suspend(cur_term)
	+#define key_undo t_key_undo(cur_term)
	+#define key_up t_key_up(cur_term)
	+#define keypad_local t_keypad_local(cur_term)
	+#define keypad_xmit t_keypad_xmit(cur_term)
	+#define lab_f0 t_lab_f0(cur_term)
	+#define lab_f1 t_lab_f1(cur_term)
	+#define lab_f2 t_lab_f2(cur_term)
	+#define lab_f3 t_lab_f3(cur_term)
	+#define lab_f4 t_lab_f4(cur_term)
	+#define lab_f5 t_lab_f5(cur_term)
	+#define lab_f6 t_lab_f6(cur_term)
	+#define lab_f7 t_lab_f7(cur_term)
	+#define lab_f8 t_lab_f8(cur_term)
	+#define lab_f9 t_lab_f9(cur_term)
	+#define lab_f10 t_lab_f10(cur_term)
	+#define label_format t_label_format(cur_term)
	+#define label_off t_label_off(cur_term)
	+#define label_on t_label_on(cur_term)
	+#define meta_off t_meta_off(cur_term)
	+#define meta_on t_meta_on(cur_term)
	+#define micro_column_address t_micro_column_address(cur_term)
	+#define micro_down t_micro_down(cur_term)
	+#define micro_left t_micro_left(cur_term)
	+#define micro_right t_micro_right(cur_term)
	+#define micro_row_address t_micro_row_address(cur_term)
	+#define micro_up t_micro_up(cur_term)
	+#define mouse_info t_mouse_info(cur_term)
	+#define newline t_newline(cur_term)
	+#define order_of_pins t_order_of_pins(cur_term)
	+#define orig_colors t_orig_colors(cur_term)
	+#define orig_pair t_orig_pair(cur_term)
	+#define pad_char t_pad_char(cur_term)
	+#define parm_dch t_parm_dch(cur_term)
	+#define parm_delete_line t_parm_delete_line(cur_term)
	+#define parm_down_cursor t_parm_down_cursor(cur_term)
	+#define parm_down_micro t_parm_down_micro(cur_term)
	+#define parm_ich t_parm_ich(cur_term)
	+#define parm_index t_parm_index(cur_term)
	+#define parm_insert_line t_parm_insert_line(cur_term)
	+#define parm_left_cursor t_parm_left_cursor(cur_term)
	+#define parm_left_micro t_parm_left_micro(cur_term)
	+#define parm_right_cursor t_parm_right_cursor(cur_term)
	+#define parm_right_micro t_parm_right_micro(cur_term)
	+#define parm_rindex t_parm_rindex(cur_term)
	+#define parm_up_cursor t_parm_up_cursor(cur_term)
	+#define parm_up_micro t_parm_up_micro(cur_term)
	+#define pc_term_options t_pc_term_options(cur_term)
	+#define pkey_key t_pkey_key(cur_term)
	+#define pkey_local t_pkey_local(cur_term)
	+#define pkey_plab t_pkey_plab(cur_term)
	+#define pkey_xmit t_pkey_xmit(cur_term)
	+#define plab_norm t_plab_norm(cur_term)
	+#define print_screen t_print_screen(cur_term)
	+#define ptr_non t_ptr_non(cur_term)
	+#define ptr_off t_ptr_off(cur_term)
	+#define ptr_on t_ptr_on(cur_term)
	+#define pulse t_pulse(cur_term)
	+#define quick_dial t_quick_dial(cur_term)
	+#define remove_clock t_remove_clock(cur_term)
	+#define repeat_char t_repeat_char(cur_term)
	+#define req_for_input t_req_for_input(cur_term)
	+#define req_mouse_pos t_req_mouse_pos(cur_term)
	+#define reset_1string t_reset_1string(cur_term)
	+#define reset_2string t_reset_2string(cur_term)
	+#define reset_3string t_reset_3string(cur_term)
	+#define reset_file t_reset_file(cur_term)
	+#define restore_cursor t_restore_cursor(cur_term)
	+#define row_address t_row_address(cur_term)
	+#define save_cursor t_save_cursor(cur_term)
	+#define scancode_escape t_scancode_escape(cur_term)
	+#define scroll_forward t_scroll_forward(cur_term)
	+#define scroll_reverse t_scroll_reverse(cur_term)
	+#define select_char_set t_select_char_set(cur_term)
	+#define set0_des_seq t_set0_des_seq(cur_term)
	+#define set1_des_seq t_set1_des_seq(cur_term)
	+#define set2_des_seq t_set2_des_seq(cur_term)
	+#define set3_des_seq t_set3_des_seq(cur_term)
	+#define set_a_attributes t_set_a_attributes(cur_term)
	+#define set_a_background t_set_a_background(cur_term)
	+#define set_a_foreground t_set_a_foreground(cur_term)
	+#define set_attributes t_set_attributes(cur_term)
	+#define set_background t_set_background(cur_term)
	+#define set_bottom_margin t_set_bottom_margin(cur_term)
	+#define set_bottom_margin_parm t_set_bottom_margin_parm(cur_term)
	+#define set_clock t_set_clock(cur_term)
	+#define set_color_band t_set_color_band(cur_term)
	+#define set_color_pair t_set_color_pair(cur_term)
	+#define set_foreground t_set_foreground(cur_term)
	+#define set_left_margin t_set_left_margin(cur_term)
	+#define set_left_margin_parm t_set_left_margin_parm(cur_term)
	+#define set_lr_margin t_set_lr_margin(cur_term)
	+#define set_page_length t_set_page_length(cur_term)
	+#define set_pglen_inch t_set_pglen_inch(cur_term)
	+#define set_right_margin t_set_right_margin(cur_term)
	+#define set_right_margin_parm t_set_right_margin_parm(cur_term)
	+#define set_tab t_set_tab(cur_term)
	+#define set_tb_margin t_set_tb_margin(cur_term)
	+#define set_top_margin t_set_top_margin(cur_term)
	+#define set_top_margin_parm t_set_top_margin_parm(cur_term)
	+#define set_window t_set_window(cur_term)
	+#define start_bit_image t_start_bit_image(cur_term)
	+#define start_char_set_def t_start_char_set_def(cur_term)
	+#define stop_bit_image t_stop_bit_image(cur_term)
	+#define stop_char_set_def t_stop_char_set_def(cur_term)
	+#define subscript_characters t_subscript_characters(cur_term)
	+#define superscript_characters t_superscript_characters(cur_term)
	+#define tab t_tab(cur_term)
	+#define these_cause_cr t_these_cause_cr(cur_term)
	+#define to_status_line t_to_status_line(cur_term)
	+#define tone t_tone(cur_term)
	+#define user0 t_user0(cur_term)
	+#define user1 t_user1(cur_term)
	+#define user2 t_user2(cur_term)
	+#define user3 t_user3(cur_term)
	+#define user4 t_user4(cur_term)
	+#define user5 t_user5(cur_term)
	+#define user6 t_user6(cur_term)
	+#define user7 t_user7(cur_term)
	+#define user8 t_user8(cur_term)
	+#define user9 t_user9(cur_term)
	+#define underline_char t_underline_char(cur_term)
	+#define up_half_line t_up_half_line(cur_term)
	+#define wait_tone t_wait_tone(cur_term)
	+#define xoff_character t_xoff_character(cur_term)
	+#define xon_character t_xon_character(cur_term)
	+#define zero_motion t_zero_motion(cur_term)
	+
	+/*
	+ * STRING DESCRIPTIONS
	+ *
	+ * acs_chars: Graphic charset pairs aAbBcC
	+ * alt_scancode_esc: Alternate escape for scancode emulation
	+ * back_tab: Back tab
	+ * bell: Audible signal (bell)
	+ * bit_image_carriage_return: Move to beginning of same row
	+ * bit_image_newline: Move to next row of the bit image
	+ * bit_image_repeat: Repeat bit-image cell #1 #2 times
	+ * carriage_return: Carriage return
	+ * change_char_pitch: Change number of characters per inch
	+ * change_line_pitch: Change number of lines per inch
	+ * change_res_horz: Change horizontal resolution
	+ * change_res_vert: Change vertical resolution
	+ * change_scroll_region: Change to lines #1 through #2 (VT100)
	+ * char_padding: Like ip but when in replace mode
	+ * char_set_names: Returns a list of character set names
	+ * clear_all_tabs: Clear all tab stops
	+ * clear_margins: Clear all margins (top, bottom and sides)
	+ * clear_screen: Clear screen and home cursor
	+ * clr_bol: Clear to beginning of line, inclusive
	+ * clr_eol: Clear to end of line
	+ * clr_eos: Clear to end of display
	+ * code_set_init: Init sequence for multiple codesets
	+ * color_names: Give name for colour #1
	+ * column_address: Set horizontal position to absolute #1
	+ * command_character: Terminal settable cmd character in prototype
	+ * create_window: Define win #1 to go from #2,#3 to #4,#5
	+ * cursor_address: Move to row #1, col #2
	+ * cursor_down: Down one line
	+ * cursor_home: Home cursor (if no cup)
	+ * cursor_invisible: Make cursor invisible
	+ * cursor_left: Move left one space
	+ * cursor_mem_address: Memory relative cursor addressing
	+ * cursor_normal: Make cursor appear normal (under vs/vi)
	+ * cursor_right: Non-destructive space (cursor or carriage right)
	+ * cursor_to_ll: Last line, first column (if no cup)
	+ * cursor_up: Upline (cursor up)
	+ * cursor_visible: Make cursor very visible
	+ * define_bit_image_region: Define rectangular bit-image region
	+ * define_char: Define a character in a character set
	+ * delete_character: Delete character
	+ * delete_line: Delete line
	+ * device_type: Indicate language/codeset support
	+ * dial_phone: Dial phone number #1
	+ * dis_status_line: Disable status line
	+ * display_clock: Display time-of-day clock
	+ * display_pc_char: Display PC character
	+ * down_half_time: Half-line down (forward 1/2 linefeed)
	+ * ena_acs: Enable alternate character set
	+ * end_bit_image_region: End a bit-image region
	+ * enter_alt_charset_mode: Start alternate character set
	+ * enter_am_mode: Turn on automatic margins
	+ * enter_blink_mode: Turn on blinking
	+ * enter_bold_mode: Turn on bold (extra bright) mode
	+ * enter_ca_mode: String to begin programs that use cup
	+ * enter_delete_mode: Delete mode (enter)
	+ * enter_dim_mode: Turn on half-bright mode
	+ * enter_doublewide_mode: Enable double wide printing
	+ * enter_draft_quality: Set draft qualify print
	+ * enter_horizontal_hl_mode: Turn on horizontal highlight mode
	+ * enter_insert_mode: Insert mode (enter)
	+ * enter_italics_mode: Enable italics
	+ * enter_left_hl_mode: Turn on left highlight mode
	+ * enter_leftward_mode: Enable leftward carriage motion
	+ * enter_low_hl_mode: Turn on low highlight mode
	+ * enter_micro_mode: Enable micro motion capabilities
	+ * enter_near_quality_letter: Set near-letter quality print
	+ * enter_normal_quality: Set normal quality print
	+ * enter_pc_charset_mode: Enter PC character display mode
	+ * enter_protected_mode: Turn on protected mode
	+ * enter_reverse_mode: Turn on reverse video mode
	+ * enter_right_hl_mode: Turn on right highlight mode
	+ * enter_scancode_mode: Enter PC scancode mode
	+ * enter_secure_mode: Turn on blank mode (characters invisible)
	+ * enter_shadow_mode: Enable shadow printing
	+ * enter_standout_mode: Begin standout mode
	+ * enter_subscript_mode: Enable subscript printing
	+ * enter_superscript_mode: Enable superscript printing
	+ * enter_top_hl_mode: Turn on top highlight mode
	+ * enter_underline_mode: Start underscore mode
	+ * enter_upward_mode: Enable upward carriage motion
	+ * enter_vertical_hl_mode: Turn on verticle highlight mode
	+ * enter_xon_mode: Turn on xon/xoff handshaking
	+ * erase_chars: Erase #1 characters
	+ * exit_alt_charset_mode: End alternate character set
	+ * exit_am_mode: Turn off automatic margins
	+ * exit_attribute_mode: Turn off all attributes
	+ * exit_ca_mode: String to end programs that use cup
	+ * exit_delete_mode: End delete mode
	+ * exit_doublewide_mode: Disable double wide printing
	+ * exit_insert_mode: End insert mode
	+ * exit_italics_mode: Disable italics
	+ * exit_leftward_mode: Enable rightward (normal) carriage motion
	+ * exit_micro_mode: Disable micro motion capabilities
	+ * exit_pc_charset_mode: Disable PC character display mode
	+ * exit_scancode_mode: Disable PC scancode mode
	+ * exit_shadow_mode: Disable shadow printing
	+ * exit_standout_mode: End standout mode
	+ * exit_subscript_mode: Disable subscript printing
	+ * exit_superscript_mode: Disable superscript printing
	+ * exit_underline_mode: End underscore mode
	+ * exit_upward_mode: Enable downward (normal) carriage motion
	+ * exit_xon_mode: Turn off xon/xoff handshaking
	+ * fixed_pause: Pause for 2-3 seconds
	+ * flash_hook: Flash the switch hook
	+ * flash_screen: Visible bell (may move cursor)
	+ * form_feed: Hardcopy terminal eject page
	+ * from_status_line: Return from status line
	+ * get_mouse: Curses should get button events
	+ * goto_window: Go to window #1
	+ * hangup: Hang-up phone
	+ * init_1string: Terminal or printer initialisation string
	+ * init_2string: Terminal or printer initialisation string
	+ * init_3string: Terminal or printer initialisation string
	+ * init_file: Name of initialisation file
	+ * init_prog: Path name of program for initialisation
	+ * initialize_color: Set colour #1 to RGB #2, #3, #4
	+ * initialize_pair: Set colour-pair #1 to fg #2, bg #3
	+ * insert_character: Insert character
	+ * insert_line: Add new blank line
	+ * insert_padding: Insert pad after character inserted
	+ * key_a1: upper left of keypad
	+ * key_a3: upper right of keypad
	+ * key_b2: center of keypad
	+ * key_backspace: set by backspace key
	+ * key_beg: 1
	+ * key_btab: sent by back-tab key
	+ * key_c1: lower left of keypad
	+ * key_c3: lower right of keypad
	+ * key_cancel: 2
	+ * key_catab: sent by clear-all-tabs key
	+ * key_clear: sent by clear-screen or erase key
	+ * key_close: 3
	+ * key_command: 4
	+ * key_copy: 5
	+ * key_create: 6
	+ * key_ctab: sent by clear-tab key
	+ * key_dc: sent by delete-character key
	+ * key_dl: sent by delete-line key
	+ * key_down: sent by terminal down-arrow key
	+ * key_eic: sent by rmir or smir in insert mode
	+ * key_end: 7
	+ * key_enter: 8
	+ * key_eol: sent by clear-to-end-of-line key
	+ * key_eos: sent by clear-to-end-of-screen key
	+ * key_exit: 9
	+ * key_f0: sent by function key f0
	+ * key_f1: sent by function key f1
	+ * key_f2: sent by function key f2
	+ * key_f3: sent by function key f3
	+ * key_f4: sent by function key f4
	+ * key_f5: sent by function key f5
	+ * key_f6: sent by function key f6
	+ * key_f7: sent by function key f7
	+ * key_f8: sent by function key f8
	+ * key_f9: sent by function key f9
	+ * key_f10: sent by function key f10
	+ * key_f11: sent by function key f11
	+ * key_f12: sent by function key f12
	+ * key_f13: sent by function key f13
	+ * key_f14: sent by function key f14
	+ * key_f15: sent by function key f15
	+ * key_f16: sent by function key f16
	+ * key_f17: sent by function key f17
	+ * key_f18: sent by function key f18
	+ * key_f19: sent by function key f19
	+ * key_f20: sent by function key f20
	+ * key_f21: sent by function key f21
	+ * key_f22: sent by function key f22
	+ * key_f23: sent by function key f23
	+ * key_f24: sent by function key f24
	+ * key_f25: sent by function key f25
	+ * key_f26: sent by function key f26
	+ * key_f27: sent by function key f27
	+ * key_f28: sent by function key f28
	+ * key_f29: sent by function key f29
	+ * key_f30: sent by function key f30
	+ * key_f31: sent by function key f31
	+ * key_f32: sent by function key f32
	+ * key_f33: sent by function key f33
	+ * key_f34: sent by function key f34
	+ * key_f35: sent by function key f35
	+ * key_f36: sent by function key f36
	+ * key_f37: sent by function key f37
	+ * key_f38: sent by function key f38
	+ * key_f39: sent by function key f39
	+ * key_f40: sent by function key f40
	+ * key_f41: sent by function key f41
	+ * key_f42: sent by function key f42
	+ * key_f43: sent by function key f43
	+ * key_f44: sent by function key f44
	+ * key_f45: sent by function key f45
	+ * key_f46: sent by function key f46
	+ * key_f47: sent by function key f47
	+ * key_f48: sent by function key f48
	+ * key_f49: sent by function key f49
	+ * key_f50: sent by function key f50
	+ * key_f51: sent by function key f51
	+ * key_f52: sent by function key f52
	+ * key_f53: sent by function key f53
	+ * key_f54: sent by function key f54
	+ * key_f55: sent by function key f55
	+ * key_f56: sent by function key f56
	+ * key_f57: sent by function key f57
	+ * key_f58: sent by function key f58
	+ * key_f59: sent by function key f59
	+ * key_f60: sent by function key f60
	+ * key_f61: sent by function key f61
	+ * key_f62: sent by function key f62
	+ * key_f63: sent by function key f63
	+ * key_find: 0
	+ * key_help: sent by help key
	+ * key_home: sent by home key
	+ * key_ic: sent by ins-char/enter ins-mode key
	+ * key_il: sent by insert-line key
	+ * key_left: sent by terminal left-arrow key
	+ * key_ll: sent by home-down key
	+ * key_mark: sent by mark key
	+ * key_message: sent by message key
	+ * key_mouse: 0631, Mouse event has occured
	+ * key_move: sent by move key
	+ * key_next: sent by next-object key
	+ * key_npage: sent by next-page key
	+ * key_open: sent by open key
	+ * key_options: sent by options key
	+ * key_ppage: sent by previous-page key
	+ * key_previous: sent by previous-object key
	+ * key_print: sent by print or copy key
	+ * key_redo: sent by redo key
	+ * key_reference: sent by ref(erence) key
	+ * key_refresh: sent by refresh key
	+ * key_replace: sent by replace key
	+ * key_restart: sent by restart key
	+ * key_resume: sent by resume key
	+ * key_right: sent by terminal right-arrow key
	+ * key_save: sent by save key
	+ * key_sbeg: sent by shifted beginning key
	+ * key_scancel: sent by shifted cancel key
	+ * key_scommand: sent by shifted command key
	+ * key_scopy: sent by shifted copy key
	+ * key_screate: sent by shifted create key
	+ * key_sdc: sent by shifted delete-char key
	+ * key_sdl: sent by shifted delete-line key
	+ * key_select: sent by select key
	+ * key_send: sent by shifted end key
	+ * key_seol: sent by shifted clear-line key
	+ * key_sexit: sent by shited exit key
	+ * key_sf: sent by scroll-forward/down key
	+ * key_sfind: sent by shifted find key
	+ * key_shelp: sent by shifted help key
	+ * key_shome: sent by shifted home key
	+ * key_sic: sent by shifted input key
	+ * key_sleft: sent by shifted left-arrow key
	+ * key_smessage: sent by shifted message key
	+ * key_smove: sent by shifted move key
	+ * key_snext: sent by shifted next key
	+ * key_soptions: sent by shifted options key
	+ * key_sprevious: sent by shifted prev key
	+ * key_sprint: sent by shifted print key
	+ * key_sr: sent by scroll-backwards/up key
	+ * key_sredo: sent by shifted redo key
	+ * key_sreplace: sent by shifted replace key
	+ * key_sright: sent by shifted right-arrow key
	+ * key_srsume: sent by shifted resume key
	+ * key_ssave: sent by shifted save key
	+ * key_ssuspend: sent by shifted suspend key
	+ * key_stab: sent by set-tab key
	+ * key_sundo: sent by shifted undo key
	+ * key_suspend: sent by suspend key
	+ * key_undo: sent by undo key
	+ * key_up: sent by terminal up-arrow key
	+ * keypad_local: Out of "keypad-transmit" mode
	+ * keypad_xmit: Put terminal in "keypad-transmit" mode
	+ * lab_f0: Labels on function key f0 if not f0
	+ * lab_f1: Labels on function key f1 if not f1
	+ * lab_f2: Labels on function key f2 if not f2
	+ * lab_f3: Labels on function key f3 if not f3
	+ * lab_f4: Labels on function key f4 if not f4
	+ * lab_f5: Labels on function key f5 if not f5
	+ * lab_f6: Labels on function key f6 if not f6
	+ * lab_f7: Labels on function key f7 if not f7
	+ * lab_f8: Labels on function key f8 if not f8
	+ * lab_f9: Labels on function key f9 if not f9
	+ * lab_f10: Labels on function key f10 if not f10
	+ * label_format: Label format
	+ * label_off: Turn off soft labels
	+ * label_on: Turn on soft labels
	+ * meta_off: Turn off "meta mode"
	+ * meta_on: Turn on "meta mode" (8th bit)
	+ * micro_column_address: Like column_address for micro adjustment
	+ * micro_down: Like cursor_down for micro adjustment
	+ * micro_left: Like cursor_left for micro adjustment
	+ * micro_right: Like cursor_right for micro adjustment
	+ * micro_row_address: Like row_address for micro adjustment
	+ * micro_up: Like cursor_up for micro adjustment
	+ * mouse_info: Mouse status information
	+ * newline: Newline (behaves like cr followed by lf)
	+ * order_of_pins: Matches software bits to print-head pins
	+ * orig_colors: Set all colour(-pair)s to original ones
	+ * orig_pair: Set default colour-pair to the original one
	+ * pad_char: Pad character (rather than NULL)
	+ * parm_dch: Delete #1 chars
	+ * parm_delete_line: Delete #1 lines
	+ * parm_down_cursor: Move down #1 lines
	+ * parm_down_micro: Like parm_down_cursor for micro adjustment
	+ * parm_ich: Insert #1 blank chars
	+ * parm_index: Scroll forward #1 lines
	+ * parm_insert_line: Add #1 new blank lines
	+ * parm_left_cursor: Move cursor left #1 lines
	+ * parm_left_micro: Like parm_left_cursor for micro adjustment
	+ * parm_right_cursor: Move right #1 spaces
	+ * parm_right_micro: Like parm_right_cursor for micro adjustment
	+ * parm_rindex: Scroll backward #1 lines
	+ * parm_up_cursor: Move cursor up #1 lines
	+ * parm_up_micro: Like parm_up_cursor for micro adjustment
	+ * pc_term_options: PC terminal options
	+ * pkey_key: Prog funct key #1 to type string #2
	+ * pkey_local: Prog funct key #1 to execute string #2
	+ * pkey_plab: Prog key #1 to xmit string #2 and show string #3
	+ * pkey_xmit: Prog funct key #1 to xmit string #2
	+ * plab_norm: Prog label #1 to show string #2
	+ * print_screen: Print contents of screen
	+ * ptr_non: Turn off printer for #1 bytes
	+ * ptr_off: Turn off the printer
	+ * ptr_on: Turn on the printer
	+ * pulse: Select pulse dialing
	+ * quick_dial: Dial phone number #1, without progress detection
	+ * remove_clock: Remove time-of-day clock
	+ * repeat_char: Repeat char #1 #2 times
	+ * req_for_input: Send next input char (for ptys)
	+ * req_mouse_pos: Request mouse position report
	+ * reset_1string: Reset terminal completely to sane modes
	+ * reset_2string: Reset terminal completely to sane modes
	+ * reset_3string: Reset terminal completely to sane modes
	+ * reset_file: Name of file containing reset string
	+ * restore_cursor: Restore cursor to position of last sc
	+ * row_address: Set vertical position to absolute #1
	+ * save_cursor: Save cursor position
	+ * scancode_escape: Escape for scancode emulation
	+ * scroll_forward: Scroll text up
	+ * scroll_reverse: Scroll text down
	+ * select_char_set: Select character set
	+ * set0_des_seq: Shift into codeset 0 (EUC set 0, ASCII)
	+ * set1_des_seq: Shift into codeset 1
	+ * set2_des_seq: Shift into codeset 2
	+ * set3_des_seq: Shift into codeset 3
	+ * set_a_attributes: Define second set of video attributes #1-#6
	+ * set_a_background: Set background colour to #1 using ANSI escape
	+ * set_a_foreground: Set foreground colour to #1 using ANSI escape
	+ * set_attributes: Define first set of video attributes #1-#9
	+ * set_background: Set background colour to #1
	+ * set_bottom_margin: Set bottom margin at current line
	+ * set_bottom_margin_parm: Set bottom margin at line #1 or #2 lines from bottom
	+ * set_clock: Set clock to hours (#1), minutes (#2), seconds (#3)
	+ * set_color_band: Change ribbon to colour #1
	+ * set_color_pair: Set current colour pair to #1
	+ * set_foreground: Set foreground colour to #1
	+ * set_left_margin: Set left margin at current column
	+ * set_left_margin_parm: Set left (right) margin at column #1 (#2)
	+ * set_lr_margin: Sets both left and right margins
	+ * set_page_length: Set page length to #1 lines
	+ * set_pglen_inch: Set page length to #1 hundredth of an inch
	+ * set_right_margin: Set right margin at current column
	+ * set_right_margin_parm: Set right margin at #1
	+ * set_tab: Set a tab in all rows, current column
	+ * set_tb_margin: Sets both top and bottom margins
	+ * set_top_margin: Set top margin at current line
	+ * set_top_margin_parm: Set top (bottom) margin at line #1 (#2)
	+ * set_window: Current window is lines #1-#2 cols #3-#4
	+ * start_bit_image: Start printing bit image graphics
	+ * start_char_set_def: Start definition of a character set
	+ * stop_bit_image: End printing bit image graphics
	+ * stop_char_set_def: End definition of a character set
	+ * subscript_characters: List of "subscript-able" characters
	+ * superscript_characters: List of "superscript-able" characters
	+ * tab: Tab to next 8-space hardware tab stop
	+ * these_cause_cr: Printing any of these characters causes cr
	+ * to_status_line: Go to status line, col #1
	+ * tone: Select tone touch dialing
	+ * user0: User string 0
	+ * user1: User string 1
	+ * user2: User string 2
	+ * user3: User string 3
	+ * user4: User string 4
	+ * user5: User string 5
	+ * user6: User string 6
	+ * user7: User string 7
	+ * user8: User string 8
	+ * user9: User string 9
	+ * underline_char: Underscore one char and move past it
	+ * up_half_line: Half-line up (reverse 1/2 linefeed)
	+ * wait_tone: Wait for dial tone
	+ * xoff_character: X-off character
	+ * xon_character: X-on character
	+ * zero_motion: No motion for the subsequent character
	+ */
	+
	+#ifndef _TERMINFO
	+typedef struct {
	+ int fildes;
	+ /* We need to expose these so that the macros work */
	+ const char *name;
	+ const char *desc;
	+ signed char *flags;
	+ short *nums;
	+ const char **strs;
	+} TERMINAL;
	+#endif
	+
	+#include <sys/cdefs.h>
	+
	+__BEGIN_DECLS
	+
	+extern TERMINAL *cur_term;
	+
	+/* setup functions */
	+int setupterm(const char , int, int );
	+TERMINAL * set_curterm(TERMINAL *);
	+int del_curterm(TERMINAL *);
	+char * termname(void);
	+char * longname(void);
	+
	+/* information functions */
	+int tigetflag(const char *);
	+int tigetnum(const char *);
	+char * tigetstr(const char *);
	+/* You should note that the spec allows stuffing a char * into a long
	+ * if the platform allows and the %pN is followed immediately by %l or %s */
	+char * tparm(const char *, long, long, long, long, long,
	+ long, long, long, long);
	+
	+/* Non standard functions, but provide a level of thread safety */
	+int ti_setupterm(TERMINAL *, const char , int, int *);
	+int ti_getflag(const TERMINAL , const char );
	+int ti_getnum(const TERMINAL , const char );
	+const char * ti_getstr(const TERMINAL , const char );
	+char * ti_parm(TERMINAL , const char ,
	+ long, long, long, long, long, long, long, long, long);
	+
	+/* These functions do not use PC or speed, but the terminal */
	+int ti_puts(const TERMINAL , const char , int,
	+ int ()(int, void ), void *);
	+int ti_putp(const TERMINAL , const char );
	+
	+/* Using tparm can be kunkly, so provide a variadic function
	+ * Numbers have to be passed as int */
	+/* This is not standard, but ncurses also provides this */
	+char * tiparm(const char *, ...);
	+/* And a thread safe version */
	+char * ti_tiparm(TERMINAL , const char , ...);
	+
	+#ifdef TPARM_TLPARM
	+/* Same as the above, but numbers have to be passed as long */
	+char * tlparm(const char *, ...);
	+/* And a thread safe version */
	+char * ti_tlparm(TERMINAL , const char , ...);
	+#endif
	+
	+/* Default to X/Open tparm, but allow it to be variadic also */
	+#ifdef TPARM_VARARGS
	+# define tparm tiparm
	+# define ti_parm ti_tiparm
	+#endif
	+
	+/* Convert a termcap string into a terminfo string.
	+ * The passed string is destroyed and the return string needs to be freed. */
	+char * captoinfo(char *);
	+
	+/* POSIX says that term.h should also pull in our termcap definitions. */
	+#include "terminfo_termcap.h"
	+
	+__END_DECLS
	+#endif
	Index: contrib/mg/terminfo_termcap.h
	===================================================================
	--- /dev/null
	+++ contrib/mg/terminfo_termcap.h
	@@ -0,0 +1,54 @@
	+/* $NetBSD: termcap.h,v 1.2 2011/04/11 21:13:09 roy Exp $ */
	+
	+/*
	+ * Copyright (c) 2009, 2011 The NetBSD Foundation, Inc.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Roy Marples.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ */
	+
	+#ifndef _TERMCAP_H_
	+#define _TERMCAP_H_
	+
	+#include <sys/cdefs.h>
	+
	+__BEGIN_DECLS
	+
	+/* Output functions.
	+ * These are still valid for terminfo. */
	+int putp(const char *);
	+int tputs(const char , int, int ()(int));
	+
	+extern short ospeed;
	+extern char PC;
	+extern char *BC;
	+extern char *UP;
	+
	+int tgetent(char , const char );
	+char * tgetstr(const char , char *);
	+int tgetflag(const char *);
	+int tgetnum(const char *);
	+char * tgoto(const char *, int, int);
	+
	+__END_DECLS
	+#endif
	Index: contrib/mg/ti.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/ti.c
	@@ -0,0 +1,126 @@
	+/* $NetBSD: ti.c,v 1.3 2013/06/07 13:16:18 roy Exp $ */
	+
	+/*
	+ * Copyright (c) 2009 The NetBSD Foundation, Inc.
	+ *
	+ * This id is derived from software contributed to The NetBSD Foundation
	+ * by Roy Marples.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source id must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ */
	+
	+#include <sys/cdefs.h>
	+
	+#include <string.h>
	+
	+#include "term_private.h"
	+#include "terminfo_term.h"
	+
	+#ifndef __UNCONST
	+#define __UNCONST(a) ((void )(unsigned long)(const void )(a))
	+#endif
	+
	+int
	+ti_getflag(const TERMINAL term, const char id)
	+{
	+ ssize_t ind;
	+ size_t i;
	+ TERMUSERDEF *ud;
	+
	+ ind = _ti_flagindex(id);
	+ if (ind != -1)
	+ return term->flags[ind];
	+ for (i = 0; i < term->_nuserdefs; i++) {
	+ ud = &term->_userdefs[i];
	+ if (ud->type == 'f' && strcmp(ud->id, id) == 0)
	+ return ud->flag;
	+ }
	+ return ABSENT_BOOLEAN;
	+}
	+
	+int
	+tigetflag(const char *id)
	+{
	+
	+ if (cur_term != NULL)
	+ return ti_getflag(cur_term, id);
	+ return ABSENT_BOOLEAN;
	+}
	+
	+int
	+ti_getnum(const TERMINAL term, const char id)
	+{
	+ ssize_t ind;
	+ size_t i;
	+ TERMUSERDEF *ud;
	+
	+ ind = _ti_numindex(id);
	+ if (ind != -1) {
	+ if (!VALID_NUMERIC(term->nums[ind]))
	+ return ABSENT_NUMERIC;
	+ return term->nums[ind];
	+ }
	+ for (i = 0; i < term->_nuserdefs; i++) {
	+ ud = &term->_userdefs[i];
	+ if (ud->type == 'n' && strcmp(ud->id, id) == 0) {
	+ if (!VALID_NUMERIC(ud->num))
	+ return ABSENT_NUMERIC;
	+ return ud->num;
	+ }
	+ }
	+ return CANCELLED_NUMERIC;
	+}
	+
	+int
	+tigetnum(const char *id)
	+{
	+
	+ if (cur_term != NULL)
	+ return ti_getnum(cur_term, id);
	+ return CANCELLED_NUMERIC;
	+}
	+
	+const char *
	+ti_getstr(const TERMINAL term, const char id)
	+{
	+ ssize_t ind;
	+ size_t i;
	+ TERMUSERDEF *ud;
	+
	+ ind = _ti_strindex(id);
	+ if (ind != -1)
	+ return term->strs[ind];
	+ for (i = 0; i < term->_nuserdefs; i++) {
	+ ud = &term->_userdefs[i];
	+ if (ud->type == 's' && strcmp(ud->id, id) == 0)
	+ return ud->str;
	+ }
	+ return (const char *)CANCELLED_STRING;
	+}
	+
	+char *
	+tigetstr(const char *id)
	+{
	+
	+ if (cur_term != NULL)
	+ return __UNCONST(ti_getstr(cur_term, id));
	+ return (char *)CANCELLED_STRING;
	+}
	Index: contrib/mg/tic.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/tic.c
	@@ -0,0 +1,629 @@
	+/* $NetBSD: tic.c,v 1.31 2017/10/02 21:53:55 joerg Exp $ */
	+
	+/*
	+ * Copyright (c) 2009, 2010 The NetBSD Foundation, Inc.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Roy Marples.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ */
	+
	+#include <sys/cdefs.h>
	+#include <sys/types.h>
	+#include <sys/queue.h>
	+#include <sys/stat.h>
	+
	+#include <ctype.h>
	+#include <err.h>
	+#include <errno.h>
	+#include <getopt.h>
	+#include <limits.h>
	+#include <fcntl.h>
	+#include <search.h>
	+#include <stdarg.h>
	+#include <stdlib.h>
	+#include <stdio.h>
	+#include <string.h>
	+#include <unistd.h>
	+#if defined(__linux__) \|\| defined(__CYGWIN__)
	+#include "util.h"
	+#elif defined(__OpenBSD__) \|\| defined(__NetBSD__) \|\| defined(__APPLE__)
	+#include <util.h>
	+#else
	+#include <libutil.h>
	+#endif
	+
	+#include "cdbw.h"
	+#include "term_private.h"
	+#include "terminfo_term.h"
	+
	+#define HASH_SIZE 16384 /* 2012-06-01: 3600 entries */
	+
	+#define __UNCONST(a) ((void )(unsigned long)(const void )(a))
	+
	+#ifndef TAILQ_REMOVE_HEAD
	+#define TAILQ_REMOVE_HEAD(head, field) do { \
	+ if (((head)->tqh_first = (head)->tqh_first->field.tqe_next) == \
	+ NULL) \
	+ (head)->tqh_last = &(head)->tqh_first; \
	+} while (/CONSTCOND/0)
	+#endif
	+
	+typedef struct term {
	+ TAILQ_ENTRY(term) next;
	+ char *name;
	+ TIC *tic;
	+ uint32_t id;
	+ struct term *base_term;
	+} TERM;
	+static TAILQ_HEAD(, term) terms = TAILQ_HEAD_INITIALIZER(terms);
	+
	+static int error_exit;
	+static int Sflag;
	+static size_t nterm, nalias;
	+
	+static void
	+dowarn(const char *fmt, ...)
	+{
	+ va_list va;
	+
	+ error_exit = 1;
	+ va_start(va, fmt);
	+ vwarnx(fmt, va);
	+ va_end(va);
	+}
	+
	+static char *
	+grow_tbuf(TBUF *tbuf, size_t len)
	+{
	+ char *buf;
	+
	+ buf = _ti_grow_tbuf(tbuf, len);
	+ if (buf == NULL)
	+ err(1, "_ti_grow_tbuf");
	+ return buf;
	+}
	+
	+/* From NetBSD sys/arch/hpc/stand/include/machine/endian.h */
	+static uint16_t
	+le16dec(const void *buf)
	+{
	+ const uint8_t p = (const uint8_t )buf;
	+
	+ return ((p[1] << 8) \| p[0]);
	+}
	+
	+static void
	+le16enc(void *buf, uint32_t u)
	+{
	+ uint8_t p = (uint8_t ) buf;
	+
	+ p[0] = u & 0xff;
	+ p[1] = ((unsigned)u >> 8) & 0xff;
	+}
	+
	+void
	+le32enc(void *buf, uint32_t u)
	+{
	+ uint8_t p = (uint8_t ) buf;
	+
	+ p[0] = u & 0xff;
	+ p[1] = (u >> 8) & 0xff;
	+ p[2] = (u >> 16) & 0xff;
	+ p[3] = (u >> 24) & 0xff;
	+}
	+
	+static int
	+save_term(struct cdbw db, TERM term)
	+{
	+ uint8_t *buf;
	+ ssize_t len;
	+ size_t slen = strlen(term->name) + 1;
	+
	+ if (term->base_term != NULL) {
	+ len = (ssize_t)slen + 7;
	+ buf = malloc(len);
	+ buf[0] = 2;
	+ le32enc(buf + 1, term->base_term->id);
	+ le16enc(buf + 5, slen);
	+ memcpy(buf + 7, term->name, slen);
	+ if (cdbw_put(db, term->name, slen, buf, len))
	+ err(1, "cdbw_put");
	+ free(buf);
	+ return 0;
	+ }
	+
	+ len = _ti_flatten(&buf, term->tic);
	+ if (len == -1)
	+ return -1;
	+
	+ if (cdbw_put_data(db, buf, len, &term->id))
	+ err(1, "cdbw_put_data");
	+ if (cdbw_put_key(db, term->name, slen, term->id))
	+ err(1, "cdbw_put_key");
	+ free(buf);
	+ return 0;
	+}
	+
	+static TERM *
	+find_term(const char *name)
	+{
	+ ENTRY elem, *elemp;
	+
	+ elem.key = __UNCONST(name);
	+ elem.data = NULL;
	+ elemp = hsearch(elem, FIND);
	+ return elemp ? (TERM *)elemp->data : NULL;
	+}
	+
	+static TERM *
	+store_term(const char name, TERM base_term)
	+{
	+ TERM *term;
	+ ENTRY elem;
	+
	+ term = calloc(1, sizeof(*term));
	+ term->name = strdup(name);
	+ TAILQ_INSERT_TAIL(&terms, term, next);
	+ elem.key = strdup(name);
	+ elem.data = term;
	+ hsearch(elem, ENTER);
	+
	+ term->base_term = base_term;
	+ if (base_term != NULL)
	+ nalias++;
	+ else
	+ nterm++;
	+
	+ return term;
	+}
	+
	+static int
	+process_entry(TBUF *buf, int flags)
	+{
	+ char p, e, *alias;
	+ TERM *term;
	+ TIC *tic;
	+
	+ if (buf->bufpos == 0)
	+ return 0;
	+ /* Terminate the string */
	+ buf->buf[buf->bufpos - 1] = '\0';
	+ /* First rewind the buffer for new entries */
	+ buf->bufpos = 0;
	+
	+ if (isspace((unsigned char)*buf->buf))
	+ return 0;
	+
	+ tic = _ti_compile(buf->buf, flags);
	+ if (tic == NULL)
	+ return 0;
	+
	+ if (find_term(tic->name) != NULL) {
	+ dowarn("%s: duplicate entry", tic->name);
	+ _ti_freetic(tic);
	+ return 0;
	+ }
	+ term = store_term(tic->name, NULL);
	+ term->tic = tic;
	+
	+ /* Create aliased terms */
	+ if (tic->alias != NULL) {
	+ alias = p = strdup(tic->alias);
	+ while (p != NULL && *p != '\0') {
	+ e = strchr(p, '\|');
	+ if (e != NULL)
	+ *e++ = '\0';
	+ if (find_term(p) != NULL) {
	+ dowarn("%s: has alias for already assigned"
	+ " term %s", tic->name, p);
	+ } else {
	+ store_term(p, term);
	+ }
	+ p = e;
	+ }
	+ free(alias);
	+ }
	+
	+ return 0;
	+}
	+
	+static void
	+merge(TIC rtic, TIC utic, int flags)
	+{
	+ char cap, flag, code, type, *str;
	+ short ind, num;
	+ size_t n;
	+
	+ cap = utic->flags.buf;
	+ for (n = utic->flags.entries; n > 0; n--) {
	+ ind = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ flag = *cap++;
	+ if (VALID_BOOLEAN(flag) &&
	+ _ti_find_cap(&rtic->flags, 'f', ind) == NULL)
	+ {
	+ _ti_grow_tbuf(&rtic->flags, sizeof(uint16_t) + 1);
	+ le16enc(rtic->flags.buf + rtic->flags.bufpos, ind);
	+ rtic->flags.bufpos += sizeof(uint16_t);
	+ rtic->flags.buf[rtic->flags.bufpos++] = flag;
	+ rtic->flags.entries++;
	+ }
	+ }
	+
	+ cap = utic->nums.buf;
	+ for (n = utic->nums.entries; n > 0; n--) {
	+ ind = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ num = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ if (VALID_NUMERIC(num) &&
	+ _ti_find_cap(&rtic->nums, 'n', ind) == NULL)
	+ {
	+ grow_tbuf(&rtic->nums, sizeof(uint16_t) * 2);
	+ le16enc(rtic->nums.buf + rtic->nums.bufpos, ind);
	+ rtic->nums.bufpos += sizeof(uint16_t);
	+ le16enc(rtic->nums.buf + rtic->nums.bufpos, num);
	+ rtic->nums.bufpos += sizeof(uint16_t);
	+ rtic->nums.entries++;
	+ }
	+ }
	+
	+ cap = utic->strs.buf;
	+ for (n = utic->strs.entries; n > 0; n--) {
	+ ind = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ num = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ if (num > 0 &&
	+ _ti_find_cap(&rtic->strs, 's', ind) == NULL)
	+ {
	+ grow_tbuf(&rtic->strs, (sizeof(uint16_t) * 2) + num);
	+ le16enc(rtic->strs.buf + rtic->strs.bufpos, ind);
	+ rtic->strs.bufpos += sizeof(uint16_t);
	+ le16enc(rtic->strs.buf + rtic->strs.bufpos, num);
	+ rtic->strs.bufpos += sizeof(uint16_t);
	+ memcpy(rtic->strs.buf + rtic->strs.bufpos,
	+ cap, num);
	+ rtic->strs.bufpos += num;
	+ rtic->strs.entries++;
	+ }
	+ cap += num;
	+ }
	+
	+ cap = utic->extras.buf;
	+ for (n = utic->extras.entries; n > 0; n--) {
	+ num = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ code = cap;
	+ cap += num;
	+ type = *cap++;
	+ flag = 0;
	+ str = NULL;
	+ switch (type) {
	+ case 'f':
	+ flag = *cap++;
	+ if (!VALID_BOOLEAN(flag))
	+ continue;
	+ break;
	+ case 'n':
	+ num = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ if (!VALID_NUMERIC(num))
	+ continue;
	+ break;
	+ case 's':
	+ num = le16dec(cap);
	+ cap += sizeof(uint16_t);
	+ str = cap;
	+ cap += num;
	+ if (num == 0)
	+ continue;
	+ break;
	+ }
	+ _ti_store_extra(rtic, 0, code, type, flag, num, str, num,
	+ flags);
	+ }
	+}
	+
	+static size_t
	+merge_use(int flags)
	+{
	+ size_t skipped, merged, memn;
	+ char cap, scap;
	+ uint16_t num;
	+ TIC rtic, utic;
	+ TERM term, uterm;;
	+
	+ skipped = merged = 0;
	+ TAILQ_FOREACH(term, &terms, next) {
	+ if (term->base_term != NULL)
	+ continue;
	+ rtic = term->tic;
	+ while ((cap = _ti_find_extra(&rtic->extras, "use")) != NULL) {
	+ if (*cap++ != 's') {
	+ dowarn("%s: use is not string", rtic->name);
	+ break;
	+ }
	+ cap += sizeof(uint16_t);
	+ if (strcmp(rtic->name, cap) == 0) {
	+ dowarn("%s: uses itself", rtic->name);
	+ goto remove;
	+ }
	+ uterm = find_term(cap);
	+ if (uterm != NULL && uterm->base_term != NULL)
	+ uterm = uterm->base_term;
	+ if (uterm == NULL) {
	+ dowarn("%s: no use record for %s",
	+ rtic->name, cap);
	+ goto remove;
	+ }
	+ utic = uterm->tic;
	+ if (strcmp(utic->name, rtic->name) == 0) {
	+ dowarn("%s: uses itself", rtic->name);
	+ goto remove;
	+ }
	+ if (_ti_find_extra(&utic->extras, "use") != NULL) {
	+ skipped++;
	+ break;
	+ }
	+ cap = _ti_find_extra(&rtic->extras, "use");
	+ merge(rtic, utic, flags);
	+ remove:
	+ /* The pointers may have changed, find the use again */
	+ cap = _ti_find_extra(&rtic->extras, "use");
	+ if (cap == NULL)
	+ dowarn("%s: use no longer exists - impossible",
	+ rtic->name);
	+ else {
	+ scap = cap - (4 + sizeof(uint16_t));
	+ cap++;
	+ num = le16dec(cap);
	+ cap += sizeof(uint16_t) + num;
	+ memn = rtic->extras.bufpos -
	+ (cap - rtic->extras.buf);
	+ memmove(scap, cap, memn);
	+ rtic->extras.bufpos -= cap - scap;
	+ cap = scap;
	+ rtic->extras.entries--;
	+ merged++;
	+ }
	+ }
	+ }
	+
	+ if (merged == 0 && skipped != 0)
	+ dowarn("circular use detected");
	+ return merged;
	+}
	+
	+static int
	+print_dump(int argc, char **argv)
	+{
	+ TERM *term;
	+ uint8_t *buf;
	+ int i, n;
	+ size_t j, col;
	+ ssize_t len;
	+
	+ printf("struct compiled_term {\n");
	+ printf("\tconst char *name;\n");
	+ printf("\tconst char *cap;\n");
	+ printf("\tsize_t caplen;\n");
	+ printf("};\n\n");
	+
	+ printf("const struct compiled_term compiled_terms[] = {\n");
	+
	+ n = 0;
	+ for (i = 0; i < argc; i++) {
	+ term = find_term(argv[i]);
	+ if (term == NULL) {
	+ warnx("%s: no description for terminal", argv[i]);
	+ continue;
	+ }
	+ if (term->base_term != NULL) {
	+ warnx("%s: cannot dump alias", argv[i]);
	+ continue;
	+ }
	+ /* Don't compile the aliases in, save space */
	+ free(term->tic->alias);
	+ term->tic->alias = NULL;
	+ len = _ti_flatten(&buf, term->tic);
	+ if (len == 0 \|\| len == -1)
	+ continue;
	+
	+ printf("\t{\n");
	+ printf("\t\t\"%s\",\n", argv[i]);
	+ n++;
	+ for (j = 0, col = 0; j < (size_t)len; j++) {
	+ if (col == 0) {
	+ printf("\t\t\"");
	+ col = 16;
	+ }
	+
	+ col += printf("\\%03o", (uint8_t)buf[j]);
	+ if (col > 75) {
	+ printf("\"%s\n",
	+ j + 1 == (size_t)len ? "," : "");
	+ col = 0;
	+ }
	+ }
	+ if (col != 0)
	+ printf("\",\n");
	+ printf("\t\t%zu\n", len);
	+ printf("\t}");
	+ if (i + 1 < argc)
	+ printf(",");
	+ printf("\n");
	+ free(buf);
	+ }
	+ printf("};\n");
	+
	+ return n;
	+}
	+
	+static void
	+write_database(const char *dbname)
	+{
	+ struct cdbw *db;
	+ char *tmp_dbname;
	+ TERM *term;
	+ int fd;
	+
	+ db = cdbw_open();
	+ if (db == NULL)
	+ err(1, "cdbw_open failed");
	+ /* Save the terms */
	+ TAILQ_FOREACH(term, &terms, next)
	+ save_term(db, term);
	+
	+ asprintf(&tmp_dbname, "%s.XXXXXX", dbname);
	+ fd = mkstemp(tmp_dbname);
	+ if (fd == -1)
	+ err(1, "creating temporary database %s failed", tmp_dbname);
	+ if (cdbw_output(db, fd, "NetBSD terminfo", cdbw_stable_seeder))
	+ err(1, "writing temporary database %s failed", tmp_dbname);
	+ if (fchmod(fd, DEFFILEMODE))
	+ err(1, "fchmod failed");
	+ if (close(fd))
	+ err(1, "writing temporary database %s failed", tmp_dbname);
	+ if (rename(tmp_dbname, dbname))
	+ err(1, "renaming %s to %s failed", tmp_dbname, dbname);
	+ free(tmp_dbname);
	+ cdbw_close(db);
	+}
	+
	+int
	+main(int argc, char **argv)
	+{
	+ int ch, cflag, sflag, flags;
	+ char source, dbname, buf, ofile;
	+ FILE *f;
	+ size_t buflen;
	+ ssize_t len;
	+ TBUF tbuf;
	+ struct term *term;
	+
	+ cflag = sflag = 0;
	+ ofile = NULL;
	+ flags = TIC_ALIAS \| TIC_DESCRIPTION \| TIC_WARNING;
	+ while ((ch = getopt(argc, argv, "Saco:sx")) != -1)
	+ switch (ch) {
	+ case 'S':
	+ Sflag = 1;
	+ /* We still compile aliases so that use= works.
	+ * However, it's removed before we flatten to save space. */
	+ flags &= ~TIC_DESCRIPTION;
	+ break;
	+ case 'a':
	+ flags \|= TIC_COMMENT;
	+ break;
	+ case 'c':
	+ cflag = 1;
	+ break;
	+ case 'o':
	+ ofile = optarg;
	+ break;
	+ case 's':
	+ sflag = 1;
	+ break;
	+ case 'x':
	+ flags \|= TIC_EXTRA;
	+ break;
	+ case '?': /* FALLTHROUGH */
	+ default:
	+ fprintf(stderr, "usage: %s [-acSsx] [-o file] source\n",
	+ getprogname());
	+ return EXIT_FAILURE;
	+ }
	+
	+ if (optind == argc)
	+ errx(1, "No source file given");
	+ source = argv[optind++];
	+ f = fopen(source, "r");
	+ if (f == NULL)
	+ err(1, "fopen: %s", source);
	+
	+ hcreate(HASH_SIZE);
	+
	+ buf = tbuf.buf = NULL;
	+ buflen = tbuf.buflen = tbuf.bufpos = 0;
	+ while ((len = getline(&buf, &buflen, f)) != -1) {
	+ /* Skip comments */
	+ if (*buf == '#')
	+ continue;
	+ if (buf[len - 1] != '\n') {
	+ process_entry(&tbuf, flags);
	+ dowarn("last line is not a comment"
	+ " and does not end with a newline");
	+ continue;
	+ }
	+ /*
	+ * If the first char is space not a space then we have a
	+ * new entry, so process it.
	+ */
	+ if (!isspace((unsigned char)*buf) && tbuf.bufpos != 0)
	+ process_entry(&tbuf, flags);
	+
	+ /* Grow the buffer if needed */
	+ grow_tbuf(&tbuf, len);
	+ /* Append the string */
	+ memcpy(tbuf.buf + tbuf.bufpos, buf, len);
	+ tbuf.bufpos += len;
	+ }
	+ free(buf);
	+ /* Process the last entry if not done already */
	+ process_entry(&tbuf, flags);
	+ free(tbuf.buf);
	+
	+ /* Merge use entries until we have merged all we can */
	+ while (merge_use(flags) != 0)
	+ ;
	+
	+ if (Sflag) {
	+ print_dump(argc - optind, argv + optind);
	+ return error_exit;
	+ }
	+
	+ if (cflag)
	+ return error_exit;
	+
	+ if (ofile == NULL)
	+ asprintf(&dbname, "%s.cdb", source);
	+ else
	+ dbname = ofile;
	+ write_database(dbname);
	+
	+ if (sflag != 0)
	+ fprintf(stderr, "%zu entries and %zu aliases written to %s\n",
	+ nterm, nalias, dbname);
	+
	+ if (ofile == NULL)
	+ free(dbname);
	+ while ((term = TAILQ_FIRST(&terms)) != NULL) {
	+ TAILQ_REMOVE_HEAD(&terms, next);
	+ _ti_freetic(term->tic);
	+ free(term->name);
	+ free(term);
	+ }
	+
	+ return EXIT_SUCCESS;
	+}
	Index: contrib/mg/tparm.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/tparm.c
	@@ -0,0 +1,620 @@
	+/* $NetBSD: tparm.c,v 1.17 2017/05/04 09:42:23 roy Exp $ */
	+
	+/*
	+ * Copyright (c) 2009, 2011, 2013 The NetBSD Foundation, Inc.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Roy Marples.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ */
	+
	+#include <sys/cdefs.h>
	+#include <sys/param.h>
	+
	+#include <ctype.h>
	+#include <errno.h>
	+#include <stdarg.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+
	+#include "term_private.h"
	+#include "terminfo_term.h"
	+
	+#define LONG_STR_MAX ((CHAR_BIT * sizeof(long)) / 3)
	+#define BUFINC 128 /* Size to increament the terminal buffer by */
	+
	+#define VA_LONG_LONG 1
	+#define VA_CHAR_INT 2
	+//#define VA_CHAR_LONG 3 /* No need for this yet */
	+
	+static TERMINAL dumbterm; / For non thread safe functions */
	+
	+typedef struct {
	+ long nums[20];
	+ char *strings[20];
	+ size_t offset;
	+} TPSTACK;
	+
	+typedef struct {
	+ long num;
	+ char *string;
	+} TPVAR;
	+
	+static int
	+push(long num, char string, TPSTACK stack)
	+{
	+ if (stack->offset >= sizeof(stack->nums)) {
	+ errno = E2BIG;
	+ return -1;
	+ }
	+ stack->nums[stack->offset] = num;
	+ stack->strings[stack->offset] = string;
	+ stack->offset++;
	+ return 0;
	+}
	+
	+static int
	+pop(long num, char string, TPSTACK stack)
	+{
	+ if (stack->offset == 0) {
	+ if (num)
	+ *num = 0;
	+ if (string)
	+ *string = NULL;
	+ errno = E2BIG;
	+ return -1;
	+ }
	+ stack->offset--;
	+ if (num)
	+ *num = stack->nums[stack->offset];
	+ if (string)
	+ *string = stack->strings[stack->offset];
	+ return 0;
	+}
	+
	+static char *
	+checkbuf(TERMINAL *term, size_t len)
	+{
	+ char *buf;
	+
	+ if (term->_bufpos + len >= term->_buflen) {
	+ len = term->_buflen + MAX(len, BUFINC);
	+ buf = realloc(term->_buf, len);
	+ if (buf == NULL)
	+ return NULL;
	+ term->_buf = buf;
	+ term->_buflen = len;
	+ }
	+ return term->_buf;
	+}
	+
	+static size_t
	+ochar(TERMINAL *term, int c)
	+{
	+ if (c == 0)
	+ c = 0200;
	+ /* Check we have space and a terminator */
	+ if (checkbuf(term, 2) == NULL)
	+ return 0;
	+ term->_buf[term->_bufpos++] = (char)c;
	+ return 1;
	+}
	+
	+static size_t
	+onum(TERMINAL term, const char fmt, int num, size_t len)
	+{
	+ int l;
	+ size_t r;
	+
	+ if (len < LONG_STR_MAX)
	+ len = LONG_STR_MAX;
	+ if (checkbuf(term, len + 2) == NULL)
	+ return 0;
	+ l = snprintf(term->_buf + term->_bufpos, len + 2, fmt, num);
	+ if (l == -1)
	+ return 0;
	+ r = (size_t)l;
	+ term->_bufpos += r;
	+ return r;
	+}
	+
	+/*
	+ Make a pass through the string so we can work out
	+ which parameters are ints and which are char *.
	+ Basically we only use char * if %p[1-9] is followed by %l or %s.
	+*/
	+int
	+_ti_parm_analyse(const char str, int piss, int piss_len)
	+{
	+ int nparm, lpop;
	+ char c;
	+
	+ nparm = 0;
	+ lpop = -1;
	+ while ((c = *str++) != '\0') {
	+ if (c != '%')
	+ continue;
	+ c = *str++;
	+ switch (c) {
	+ case 'l': /* FALLTHROUGH */
	+ case 's':
	+ if (lpop > 0) {
	+ if (lpop <= piss_len)
	+ piss[lpop - 1] = 1;
	+ else if (piss)
	+ errno = E2BIG;
	+ }
	+ break;
	+ case 'p':
	+ c = *str++;
	+ if (c < '1' \|\| c > '9') {
	+ errno = EINVAL;
	+ continue;
	+ } else {
	+ lpop = c - '0';
	+ if (lpop > nparm)
	+ nparm = lpop;
	+ }
	+ break;
	+ default:
	+ lpop = -1;
	+ }
	+ }
	+
	+ return nparm;
	+}
	+
	+static char *
	+_ti_tiparm(TERMINAL term, const char str, int va_type, va_list parms)
	+{
	+ char c, fmt[64], fp, ostr;
	+ long val, val2;
	+ long dnums[26]; /* dynamic variables a-z, not preserved */
	+ size_t l, max, width, precision, olen;
	+ TPSTACK stack;
	+ TPVAR params[TPARM_MAX];
	+ unsigned int done, dot, minus;
	+ int piss[TPARM_MAX]; /* Parameter IS String - piss ;) */
	+
	+ if (str == NULL)
	+ return NULL;
	+
	+ /*
	+ If not passed a terminal, malloc a dummy one.
	+ This means we can preserve buffers and variables per terminal and
	+ still work with non thread safe functions (which sadly are still the
	+ norm and standard).
	+ */
	+ if (term == NULL) {
	+ if (dumbterm == NULL) {
	+ dumbterm = malloc(sizeof(*dumbterm));
	+ if (dumbterm == NULL)
	+ return NULL;
	+ dumbterm->_buflen = 0;
	+ }
	+ term = dumbterm;
	+ }
	+
	+ term->_bufpos = 0;
	+ /* Ensure we have an initial buffer */
	+ if (term->_buflen == 0) {
	+ term->_buf = malloc(BUFINC);
	+ if (term->_buf == NULL)
	+ return NULL;
	+ term->_buflen = BUFINC;
	+ }
	+
	+ memset(&piss, 0, sizeof(piss));
	+ max = (size_t)_ti_parm_analyse(str, piss, TPARM_MAX);
	+
	+ /* Put our parameters into variables */
	+ memset(&params, 0, sizeof(params));
	+ for (l = 0; l < max; l++) {
	+ if (piss[l]) {
	+ if (va_type == VA_LONG_LONG) {
	+ /* This only works if char * fits into a long
	+ * on this platform. */
	+ if (sizeof(char ) <= sizeof(long)/CONSTCOND*/)
	+ params[l].string =
	+ (char *)va_arg(parms, long);
	+ else {
	+ errno = ENOTSUP;
	+ return NULL;
	+ }
	+ } else
	+ params[l].string = va_arg(parms, char *);
	+ } else {
	+ if (va_type == VA_CHAR_INT)
	+ params[l].num = (long)va_arg(parms, int);
	+ else
	+ params[l].num = va_arg(parms, long);
	+ }
	+ }
	+
	+ memset(&stack, 0, sizeof(stack));
	+ while ((c = *str++) != '\0') {
	+ if (c != '%' \|\| (c = *str++) == '%') {
	+ if (c == '\0')
	+ break;
	+ if (ochar(term, c) == 0)
	+ return NULL;
	+ continue;
	+ }
	+
	+ /* Handle formatting. */
	+ fp = fmt;
	+ *fp++ = '%';
	+ done = dot = minus = width = precision = 0;
	+ val = 0;
	+ while (done == 0 && (size_t)(fp - fmt) < sizeof(fmt)) {
	+ switch (c) {
	+ case 'c': /* FALLTHROUGH */
	+ case 's':
	+ *fp++ = c;
	+ done = 1;
	+ break;
	+ case 'd': /* FALLTHROUGH */
	+ case 'o': /* FALLTHROUGH */
	+ case 'x': /* FALLTHROUGH */
	+ case 'X': /* FALLTHROUGH */
	+ *fp++ = 'l';
	+ *fp++ = c;
	+ done = 1;
	+ break;
	+ case '#': /* FALLTHROUGH */
	+ case ' ':
	+ *fp++ = c;
	+ break;
	+ case '.':
	+ *fp++ = c;
	+ if (dot == 0) {
	+ dot = 1;
	+ width = (size_t)val;
	+ } else
	+ done = 2;
	+ val = 0;
	+ break;
	+ case ':':
	+ minus = 1;
	+ break;
	+ case '-':
	+ if (minus)
	+ *fp++ = c;
	+ else
	+ done = 1;
	+ break;
	+ default:
	+ if (isdigit((unsigned char)c)) {
	+ val = (val * 10) + (c - '0');
	+ if (val > 10000)
	+ done = 2;
	+ else
	+ *fp++ = c;
	+ } else
	+ done = 1;
	+ }
	+ if (done == 0)
	+ c = *str++;
	+ }
	+ if (done == 2) {
	+ /* Found an error in the format */
	+ fp = fmt + 1;
	+ fp = str;
	+ olen = 0;
	+ } else {
	+ if (dot == 0)
	+ width = (size_t)val;
	+ else
	+ precision = (size_t)val;
	+ olen = MAX(width, precision);
	+ }
	+ *fp++ = '\0';
	+
	+ /* Handle commands */
	+ switch (c) {
	+ case 'c':
	+ pop(&val, NULL, &stack);
	+ if (ochar(term, (unsigned char)val) == 0)
	+ return NULL;
	+ break;
	+ case 's':
	+ pop(NULL, &ostr, &stack);
	+ if (ostr != NULL) {
	+ int r;
	+
	+ l = strlen(ostr);
	+ if (l < (size_t)olen)
	+ l = olen;
	+ if (checkbuf(term, (size_t)(l + 1)) == NULL)
	+ return NULL;
	+ r = snprintf(term->_buf + term->_bufpos, l + 1,
	+ fmt, ostr);
	+ if (r != -1)
	+ term->_bufpos += (size_t)r;
	+ }
	+ break;
	+ case 'l':
	+ pop(NULL, &ostr, &stack);
	+ if (ostr == NULL)
	+ l = 0;
	+ else
	+ l = strlen(ostr);
	+#ifdef NCURSES_COMPAT_57
	+ if (onum(term, "%ld", (long)l, 0) == 0)
	+ return NULL;
	+#else
	+ push((long)l, NULL, &stack);
	+#endif
	+ break;
	+ case 'd': /* FALLTHROUGH */
	+ case 'o': /* FALLTHROUGH */
	+ case 'x': /* FALLTHROUGH */
	+ case 'X':
	+ pop(&val, NULL, &stack);
	+ if (onum(term, fmt, (int)val, olen) == 0)
	+ return NULL;
	+ break;
	+ case 'p':
	+ if (str < '1' \|\| str > '9')
	+ break;
	+ l = (size_t)(*str++ - '1');
	+ if (push(params[l].num, params[l].string, &stack))
	+ return NULL;
	+ break;
	+ case 'P':
	+ pop(&val, NULL, &stack);
	+ if (str >= 'a' && str <= 'z')
	+ dnums[*str - 'a'] = val;
	+ else if (str >= 'A' && str <= 'Z')
	+ term->_snums[*str - 'A'] = val;
	+ break;
	+ case 'g':
	+ if (str >= 'a' && str <= 'z') {
	+ if (push(dnums[*str - 'a'], NULL, &stack))
	+ return NULL;
	+ } else if (str >= 'A' && str <= 'Z') {
	+ if (push(term->_snums[*str - 'A'],
	+ NULL, &stack))
	+ return NULL;
	+ }
	+ break;
	+ case 'i':
	+ if (piss[0] == 0)
	+ params[0].num++;
	+ if (piss[1] == 0)
	+ params[1].num++;
	+ break;
	+ case '\'':
	+ if (push((long)(unsigned char)*str++, NULL, &stack))
	+ return NULL;
	+ while (str != '\0' && str != '\'')
	+ str++;
	+ if (*str == '\'')
	+ str++;
	+ break;
	+ case '{':
	+ val = 0;
	+ for (; isdigit((unsigned char)*str); str++)
	+ val = (val * 10) + (*str - '0');
	+ if (push(val, NULL, &stack))
	+ return NULL;
	+ while (str != '\0' && str != '}')
	+ str++;
	+ if (*str == '}')
	+ str++;
	+ break;
	+ case '+': /* FALLTHROUGH */
	+ case '-': /* FALLTHROUGH */
	+ case '': / FALLTHROUGH */
	+ case '/': /* FALLTHROUGH */
	+ case 'm': /* FALLTHROUGH */
	+ case 'A': /* FALLTHROUGH */
	+ case 'O': /* FALLTHROUGH */
	+ case '&': /* FALLTHROUGH */
	+ case '\|': /* FALLTHROUGH */
	+ case '^': /* FALLTHROUGH */
	+ case '=': /* FALLTHROUGH */
	+ case '<': /* FALLTHROUGH */
	+ case '>':
	+ pop(&val, NULL, &stack);
	+ pop(&val2, NULL, &stack);
	+ switch (c) {
	+ case '+':
	+ val = val + val2;
	+ break;
	+ case '-':
	+ val = val2 - val;
	+ break;
	+ case '*':
	+ val = val * val2;
	+ break;
	+ case '/':
	+ val = val ? val2 / val : 0;
	+ break;
	+ case 'm':
	+ val = val ? val2 % val : 0;
	+ break;
	+ case 'A':
	+ val = val && val2;
	+ break;
	+ case 'O':
	+ val = val \|\| val2;
	+ break;
	+ case '&':
	+ val = val & val2;
	+ break;
	+ case '\|':
	+ val = val \| val2;
	+ break;
	+ case '^':
	+ val = val ^ val2;
	+ break;
	+ case '=':
	+ val = val == val2;
	+ break;
	+ case '<':
	+ val = val2 < val;
	+ break;
	+ case '>':
	+ val = val2 > val;
	+ break;
	+ }
	+ if (push(val, NULL, &stack))
	+ return NULL;
	+ break;
	+ case '!':
	+ case '~':
	+ pop(&val, NULL, &stack);
	+ switch (c) {
	+ case '!':
	+ val = !val;
	+ break;
	+ case '~':
	+ val = ~val;
	+ break;
	+ }
	+ if (push(val, NULL, &stack))
	+ return NULL;
	+ break;
	+ case '?': /* if */
	+ break;
	+ case 't': /* then */
	+ pop(&val, NULL, &stack);
	+ if (val == 0) {
	+ l = 0;
	+ for (; *str != '\0'; str++) {
	+ if (*str != '%')
	+ continue;
	+ str++;
	+ if (*str == '?')
	+ l++;
	+ else if (*str == ';') {
	+ if (l > 0)
	+ l--;
	+ else {
	+ str++;
	+ break;
	+ }
	+ } else if (*str == 'e' && l == 0) {
	+ str++;
	+ break;
	+ }
	+ }
	+ }
	+ break;
	+ case 'e': /* else */
	+ l = 0;
	+ for (; *str != '\0'; str++) {
	+ if (*str != '%')
	+ continue;
	+ str++;
	+ if (*str == '?')
	+ l++;
	+ else if (*str == ';') {
	+ if (l > 0)
	+ l--;
	+ else {
	+ str++;
	+ break;
	+ }
	+ }
	+ }
	+ break;
	+ case ';': /* fi */
	+ break;
	+ }
	+ }
	+ term->_buf[term->_bufpos] = '\0';
	+ return term->_buf;
	+}
	+
	+char *
	+ti_tiparm(TERMINAL term, const char str, ...)
	+{
	+ va_list va;
	+ char *ret;
	+
	+ va_start(va, str);
	+ ret = _ti_tiparm(term, str, VA_CHAR_INT, va);
	+ va_end(va);
	+ return ret;
	+}
	+
	+char *
	+tiparm(const char *str, ...)
	+{
	+ va_list va;
	+ char *ret;
	+
	+ va_start(va, str);
	+ ret = _ti_tiparm(NULL, str, VA_CHAR_INT, va);
	+ va_end(va);
	+ return ret;
	+}
	+
	+#ifdef VA_CHAR_LONG
	+char *
	+ti_tlparm(TERMINAL term, const char str, ...)
	+{
	+ va_list va;
	+ char *ret;
	+
	+ va_start(va, str);
	+ ret = _ti_tiparm(term, str, VA_CHAR_LONG, va);
	+ va_end(va);
	+ return ret;
	+}
	+
	+char *
	+tlparm(const char *str, ...)
	+{
	+ va_list va;
	+ char *ret;
	+
	+ va_start(va, str);
	+ ret = _ti_tiparm(NULL, str, VA_CHAR_LONG, va);
	+ va_end(va);
	+ return ret;
	+}
	+#endif
	+
	+static char *
	+_tparm(const char *str, ...)
	+{
	+ va_list va;
	+ char *ret;
	+
	+ va_start(va, str);
	+ ret = _ti_tiparm(NULL, str, VA_LONG_LONG, va);
	+ va_end(va);
	+ return ret;
	+}
	+
	+char *
	+tparm(const char *str,
	+ long p1, long p2, long p3, long p4, long p5,
	+ long p6, long p7, long p8, long p9)
	+{
	+
	+ return _tparm(str, p1, p2, p3, p4, p5, p6, p7, p8, p9);
	+}
	Index: contrib/mg/tputs.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/tputs.c
	@@ -0,0 +1,173 @@
	+/* $NetBSD: tputs.c,v 1.5 2019/10/03 18:02:05 christos Exp $ */
	+
	+/*
	+ * Copyright (c) 2009 The NetBSD Foundation, Inc.
	+ *
	+ * This code is derived from software contributed to The NetBSD Foundation
	+ * by Roy Marples.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ */
	+
	+#include <sys/cdefs.h>
	+
	+#include <ctype.h>
	+#include <stdio.h>
	+#include <string.h>
	+
	+#include "term_private.h"
	+#include "terminfo_term.h"
	+
	+#ifndef __arraycount
	+#define __arraycount(__x) (sizeof(__x) / sizeof(__x[0]))
	+#endif
	+
	+/*
	+ * The following array gives the number of tens of milliseconds per
	+ * character for each speed as returned by gtty. Thus since 300
	+ * baud returns a 7, there are 33.3 milliseconds per char at 300 baud.
	+ */
	+static const short tmspc10[] = {
	+ 0, 2000, 1333, 909, 743, 666, 500, 333, 166, 83, 55, 41, 20, 10, 5
	+};
	+
	+short ospeed;
	+char PC;
	+
	+static int
	+_ti_calcdelay(const char *str, int affcnt, int mand)
	+{
	+ int i;
	+
	+ i = 0;
	+ /* Convert the delay */
	+ while (isdigit((const unsigned char )*str))
	+ i = i * 10 + (str)++ - '0';
	+ i *= 10;
	+ if ((str) == '.') {
	+ (*str)++;
	+ if (isdigit((const unsigned char )*str))
	+ i += (str) - '0';
	+ while (isdigit((const unsigned char )*str))
	+ (*str)++;
	+ }
	+ if ((str) == '*') {
	+ (*str)++;
	+ i *= affcnt;
	+ } else if ((str) == '/') {
	+ (*str)++;
	+ if (mand != NULL)
	+ *mand = 1;
	+ }
	+ return i;
	+}
	+
	+static void
	+_ti_outputdelay(int delay, short os, char pc,
	+ int (outc)(int, void ), void *args)
	+{
	+ int mspc10;
	+
	+ if (delay < 1 \|\| os < 1 \|\| (size_t)os >= __arraycount(tmspc10))
	+ return;
	+
	+ mspc10 = tmspc10[os];
	+ delay += mspc10 / 2;
	+ for (delay /= mspc10; delay > 0; delay--)
	+ outc(pc, args);
	+}
	+
	+static int
	+_ti_puts(int dodelay, short os, char pc,
	+ const char str, int affcnt, int (outc)(int, void ), void args)
	+{
	+ int taildelay, delay, mand;
	+
	+ if (str == NULL)
	+ return OK;
	+
	+ taildelay = _ti_calcdelay(&str, affcnt, NULL);
	+
	+ /* Output the string with embedded delays */
	+ for (; *str != '\0'; str++) {
	+ if (str[0] != '$' \|\|
	+ str[1] != '<' \|\|
	+ !(isdigit((const unsigned char)str[2]) \|\| str[2] == '.') \|\|
	+ strchr(str + 3, '>') == NULL)
	+ {
	+ outc(*str, args);
	+ } else {
	+ str += 2;
	+ mand = 0;
	+ delay = _ti_calcdelay(&str, affcnt, &mand);
	+ if (dodelay != 0 \|\| mand != 0)
	+ _ti_outputdelay(delay, os, pc, outc, args);
	+ }
	+ }
	+
	+ /* Delay if needed */
	+ if (dodelay)
	+ _ti_outputdelay(taildelay, os, pc, outc, args);
	+
	+ return OK;
	+}
	+
	+int
	+ti_puts(const TERMINAL term, const char str, int affcnt,
	+ int (outc)(int, void ), void *args)
	+{
	+ int dodelay;
	+ char pc;
	+
	+ dodelay = (str == t_bell(term) \|\|
	+ str == t_flash_screen(term) \|\|
	+ (t_xon_xoff(term) == 0 && t_padding_baud_rate(term) != 0));
	+
	+ if (t_pad_char(term) == NULL)
	+ pc = '\0';
	+ else
	+ pc = *t_pad_char(term);
	+ return _ti_puts(dodelay, term->_ospeed, pc,
	+ str, affcnt, outc, args);
	+}
	+
	+int
	+ti_putp(const TERMINAL term, const char str)
	+{
	+
	+ return ti_puts(term, str, 1,
	+ (int ()(int, void ))(void *)putchar, NULL);
	+}
	+
	+int
	+tputs(const char str, int affcnt, int (outc)(int))
	+{
	+
	+ return _ti_puts(1, ospeed, PC, str, affcnt,
	+ (int ()(int, void ))(void *)outc, NULL);
	+}
	+
	+int
	+putp(const char *str)
	+{
	+
	+ return tputs(str, 1, putchar);
	+}
	Index: contrib/mg/tree.h
	===================================================================
	--- /dev/null
	+++ contrib/mg/tree.h
	@@ -0,0 +1,748 @@
	+/* $OpenBSD: tree.h,v 1.14 2015/05/25 03:07:49 deraadt Exp $ */
	+/*
	+ * Copyright 2002 Niels Provos <provos@citi.umich.edu>
	+ * All rights reserved.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	+ */
	+
	+#ifndef _SYS_TREE_H_
	+#define _SYS_TREE_H_
	+
	+/*
	+ * This file defines data structures for different types of trees:
	+ * splay trees and red-black trees.
	+ *
	+ * A splay tree is a self-organizing data structure. Every operation
	+ * on the tree causes a splay to happen. The splay moves the requested
	+ * node to the root of the tree and partly rebalances it.
	+ *
	+ * This has the benefit that request locality causes faster lookups as
	+ * the requested nodes move to the top of the tree. On the other hand,
	+ * every lookup causes memory writes.
	+ *
	+ * The Balance Theorem bounds the total access time for m operations
	+ * and n inserts on an initially empty tree as O((m + n)lg n). The
	+ * amortized cost for a sequence of m accesses to a splay tree is O(lg n);
	+ *
	+ * A red-black tree is a binary search tree with the node color as an
	+ * extra attribute. It fulfills a set of conditions:
	+ * - every search path from the root to a leaf consists of the
	+ * same number of black nodes,
	+ * - each red node (except for the root) has a black parent,
	+ * - each leaf node is black.
	+ *
	+ * Every operation on a red-black tree is bounded as O(lg n).
	+ * The maximum height of a red-black tree is 2lg (n+1).
	+ */
	+
	+#define SPLAY_HEAD(name, type) \
	+struct name { \
	+ struct type sph_root; / root of the tree */ \
	+}
	+
	+#define SPLAY_INITIALIZER(root) \
	+ { NULL }
	+
	+#define SPLAY_INIT(root) do { \
	+ (root)->sph_root = NULL; \
	+} while (0)
	+
	+#define SPLAY_ENTRY(type) \
	+struct { \
	+ struct type spe_left; / left element */ \
	+ struct type spe_right; / right element */ \
	+}
	+
	+#define SPLAY_LEFT(elm, field) (elm)->field.spe_left
	+#define SPLAY_RIGHT(elm, field) (elm)->field.spe_right
	+#define SPLAY_ROOT(head) (head)->sph_root
	+#define SPLAY_EMPTY(head) (SPLAY_ROOT(head) == NULL)
	+
	+/* SPLAY_ROTATE_{LEFT,RIGHT} expect that tmp hold SPLAY_{RIGHT,LEFT} */
	+#define SPLAY_ROTATE_RIGHT(head, tmp, field) do { \
	+ SPLAY_LEFT((head)->sph_root, field) = SPLAY_RIGHT(tmp, field); \
	+ SPLAY_RIGHT(tmp, field) = (head)->sph_root; \
	+ (head)->sph_root = tmp; \
	+} while (0)
	+
	+#define SPLAY_ROTATE_LEFT(head, tmp, field) do { \
	+ SPLAY_RIGHT((head)->sph_root, field) = SPLAY_LEFT(tmp, field); \
	+ SPLAY_LEFT(tmp, field) = (head)->sph_root; \
	+ (head)->sph_root = tmp; \
	+} while (0)
	+
	+#define SPLAY_LINKLEFT(head, tmp, field) do { \
	+ SPLAY_LEFT(tmp, field) = (head)->sph_root; \
	+ tmp = (head)->sph_root; \
	+ (head)->sph_root = SPLAY_LEFT((head)->sph_root, field); \
	+} while (0)
	+
	+#define SPLAY_LINKRIGHT(head, tmp, field) do { \
	+ SPLAY_RIGHT(tmp, field) = (head)->sph_root; \
	+ tmp = (head)->sph_root; \
	+ (head)->sph_root = SPLAY_RIGHT((head)->sph_root, field); \
	+} while (0)
	+
	+#define SPLAY_ASSEMBLE(head, node, left, right, field) do { \
	+ SPLAY_RIGHT(left, field) = SPLAY_LEFT((head)->sph_root, field); \
	+ SPLAY_LEFT(right, field) = SPLAY_RIGHT((head)->sph_root, field);\
	+ SPLAY_LEFT((head)->sph_root, field) = SPLAY_RIGHT(node, field); \
	+ SPLAY_RIGHT((head)->sph_root, field) = SPLAY_LEFT(node, field); \
	+} while (0)
	+
	+/* Generates prototypes and inline functions */
	+
	+#define SPLAY_PROTOTYPE(name, type, field, cmp) \
	+void name##_SPLAY(struct name , struct type ); \
	+void name##_SPLAY_MINMAX(struct name *, int); \
	+struct type name##_SPLAY_INSERT(struct name , struct type *); \
	+struct type name##_SPLAY_REMOVE(struct name , struct type *); \
	+ \
	+/* Finds the node with the same key as elm */ \
	+static __inline struct type * \
	+name##_SPLAY_FIND(struct name head, struct type elm) \
	+{ \
	+ if (SPLAY_EMPTY(head)) \
	+ return(NULL); \
	+ name##_SPLAY(head, elm); \
	+ if ((cmp)(elm, (head)->sph_root) == 0) \
	+ return (head->sph_root); \
	+ return (NULL); \
	+} \
	+ \
	+static __inline struct type * \
	+name##_SPLAY_NEXT(struct name head, struct type elm) \
	+{ \
	+ name##_SPLAY(head, elm); \
	+ if (SPLAY_RIGHT(elm, field) != NULL) { \
	+ elm = SPLAY_RIGHT(elm, field); \
	+ while (SPLAY_LEFT(elm, field) != NULL) { \
	+ elm = SPLAY_LEFT(elm, field); \
	+ } \
	+ } else \
	+ elm = NULL; \
	+ return (elm); \
	+} \
	+ \
	+static __inline struct type * \
	+name##_SPLAY_MIN_MAX(struct name *head, int val) \
	+{ \
	+ name##_SPLAY_MINMAX(head, val); \
	+ return (SPLAY_ROOT(head)); \
	+}
	+
	+/* Main splay operation.
	+ * Moves node close to the key of elm to top
	+ */
	+#define SPLAY_GENERATE(name, type, field, cmp) \
	+struct type * \
	+name##_SPLAY_INSERT(struct name head, struct type elm) \
	+{ \
	+ if (SPLAY_EMPTY(head)) { \
	+ SPLAY_LEFT(elm, field) = SPLAY_RIGHT(elm, field) = NULL; \
	+ } else { \
	+ int __comp; \
	+ name##_SPLAY(head, elm); \
	+ __comp = (cmp)(elm, (head)->sph_root); \
	+ if(__comp < 0) { \
	+ SPLAY_LEFT(elm, field) = SPLAY_LEFT((head)->sph_root, field);\
	+ SPLAY_RIGHT(elm, field) = (head)->sph_root; \
	+ SPLAY_LEFT((head)->sph_root, field) = NULL; \
	+ } else if (__comp > 0) { \
	+ SPLAY_RIGHT(elm, field) = SPLAY_RIGHT((head)->sph_root, field);\
	+ SPLAY_LEFT(elm, field) = (head)->sph_root; \
	+ SPLAY_RIGHT((head)->sph_root, field) = NULL; \
	+ } else \
	+ return ((head)->sph_root); \
	+ } \
	+ (head)->sph_root = (elm); \
	+ return (NULL); \
	+} \
	+ \
	+struct type * \
	+name##_SPLAY_REMOVE(struct name head, struct type elm) \
	+{ \
	+ struct type *__tmp; \
	+ if (SPLAY_EMPTY(head)) \
	+ return (NULL); \
	+ name##_SPLAY(head, elm); \
	+ if ((cmp)(elm, (head)->sph_root) == 0) { \
	+ if (SPLAY_LEFT((head)->sph_root, field) == NULL) { \
	+ (head)->sph_root = SPLAY_RIGHT((head)->sph_root, field);\
	+ } else { \
	+ __tmp = SPLAY_RIGHT((head)->sph_root, field); \
	+ (head)->sph_root = SPLAY_LEFT((head)->sph_root, field);\
	+ name##_SPLAY(head, elm); \
	+ SPLAY_RIGHT((head)->sph_root, field) = __tmp; \
	+ } \
	+ return (elm); \
	+ } \
	+ return (NULL); \
	+} \
	+ \
	+void \
	+name##_SPLAY(struct name head, struct type elm) \
	+{ \
	+ struct type __node, __left, __right, *__tmp; \
	+ int __comp; \
	+\
	+ SPLAY_LEFT(&__node, field) = SPLAY_RIGHT(&__node, field) = NULL;\
	+ __left = __right = &__node; \
	+\
	+ while ((__comp = (cmp)(elm, (head)->sph_root))) { \
	+ if (__comp < 0) { \
	+ __tmp = SPLAY_LEFT((head)->sph_root, field); \
	+ if (__tmp == NULL) \
	+ break; \
	+ if ((cmp)(elm, __tmp) < 0){ \
	+ SPLAY_ROTATE_RIGHT(head, __tmp, field); \
	+ if (SPLAY_LEFT((head)->sph_root, field) == NULL)\
	+ break; \
	+ } \
	+ SPLAY_LINKLEFT(head, __right, field); \
	+ } else if (__comp > 0) { \
	+ __tmp = SPLAY_RIGHT((head)->sph_root, field); \
	+ if (__tmp == NULL) \
	+ break; \
	+ if ((cmp)(elm, __tmp) > 0){ \
	+ SPLAY_ROTATE_LEFT(head, __tmp, field); \
	+ if (SPLAY_RIGHT((head)->sph_root, field) == NULL)\
	+ break; \
	+ } \
	+ SPLAY_LINKRIGHT(head, __left, field); \
	+ } \
	+ } \
	+ SPLAY_ASSEMBLE(head, &__node, __left, __right, field); \
	+} \
	+ \
	+/* Splay with either the minimum or the maximum element \
	+ * Used to find minimum or maximum element in tree. \
	+ */ \
	+void name##_SPLAY_MINMAX(struct name *head, int __comp) \
	+{ \
	+ struct type __node, __left, __right, *__tmp; \
	+\
	+ SPLAY_LEFT(&__node, field) = SPLAY_RIGHT(&__node, field) = NULL;\
	+ __left = __right = &__node; \
	+\
	+ while (1) { \
	+ if (__comp < 0) { \
	+ __tmp = SPLAY_LEFT((head)->sph_root, field); \
	+ if (__tmp == NULL) \
	+ break; \
	+ if (__comp < 0){ \
	+ SPLAY_ROTATE_RIGHT(head, __tmp, field); \
	+ if (SPLAY_LEFT((head)->sph_root, field) == NULL)\
	+ break; \
	+ } \
	+ SPLAY_LINKLEFT(head, __right, field); \
	+ } else if (__comp > 0) { \
	+ __tmp = SPLAY_RIGHT((head)->sph_root, field); \
	+ if (__tmp == NULL) \
	+ break; \
	+ if (__comp > 0) { \
	+ SPLAY_ROTATE_LEFT(head, __tmp, field); \
	+ if (SPLAY_RIGHT((head)->sph_root, field) == NULL)\
	+ break; \
	+ } \
	+ SPLAY_LINKRIGHT(head, __left, field); \
	+ } \
	+ } \
	+ SPLAY_ASSEMBLE(head, &__node, __left, __right, field); \
	+}
	+
	+#define SPLAY_NEGINF -1
	+#define SPLAY_INF 1
	+
	+#define SPLAY_INSERT(name, x, y) name##_SPLAY_INSERT(x, y)
	+#define SPLAY_REMOVE(name, x, y) name##_SPLAY_REMOVE(x, y)
	+#define SPLAY_FIND(name, x, y) name##_SPLAY_FIND(x, y)
	+#define SPLAY_NEXT(name, x, y) name##_SPLAY_NEXT(x, y)
	+#define SPLAY_MIN(name, x) (SPLAY_EMPTY(x) ? NULL \
	+ : name##_SPLAY_MIN_MAX(x, SPLAY_NEGINF))
	+#define SPLAY_MAX(name, x) (SPLAY_EMPTY(x) ? NULL \
	+ : name##_SPLAY_MIN_MAX(x, SPLAY_INF))
	+
	+#define SPLAY_FOREACH(x, name, head) \
	+ for ((x) = SPLAY_MIN(name, head); \
	+ (x) != NULL; \
	+ (x) = SPLAY_NEXT(name, head, x))
	+
	+/* Macros that define a red-black tree */
	+#define RB_HEAD(name, type) \
	+struct name { \
	+ struct type rbh_root; / root of the tree */ \
	+}
	+
	+#define RB_INITIALIZER(root) \
	+ { NULL }
	+
	+#define RB_INIT(root) do { \
	+ (root)->rbh_root = NULL; \
	+} while (0)
	+
	+#define RB_BLACK 0
	+#define RB_RED 1
	+#define RB_ENTRY(type) \
	+struct { \
	+ struct type rbe_left; / left element */ \
	+ struct type rbe_right; / right element */ \
	+ struct type rbe_parent; / parent element */ \
	+ int rbe_color; /* node color */ \
	+}
	+
	+#define RB_LEFT(elm, field) (elm)->field.rbe_left
	+#define RB_RIGHT(elm, field) (elm)->field.rbe_right
	+#define RB_PARENT(elm, field) (elm)->field.rbe_parent
	+#define RB_COLOR(elm, field) (elm)->field.rbe_color
	+#define RB_ROOT(head) (head)->rbh_root
	+#define RB_EMPTY(head) (RB_ROOT(head) == NULL)
	+
	+#define RB_SET(elm, parent, field) do { \
	+ RB_PARENT(elm, field) = parent; \
	+ RB_LEFT(elm, field) = RB_RIGHT(elm, field) = NULL; \
	+ RB_COLOR(elm, field) = RB_RED; \
	+} while (0)
	+
	+#define RB_SET_BLACKRED(black, red, field) do { \
	+ RB_COLOR(black, field) = RB_BLACK; \
	+ RB_COLOR(red, field) = RB_RED; \
	+} while (0)
	+
	+#ifndef RB_AUGMENT
	+#define RB_AUGMENT(x) do {} while (0)
	+#endif
	+
	+#define RB_ROTATE_LEFT(head, elm, tmp, field) do { \
	+ (tmp) = RB_RIGHT(elm, field); \
	+ if ((RB_RIGHT(elm, field) = RB_LEFT(tmp, field))) { \
	+ RB_PARENT(RB_LEFT(tmp, field), field) = (elm); \
	+ } \
	+ RB_AUGMENT(elm); \
	+ if ((RB_PARENT(tmp, field) = RB_PARENT(elm, field))) { \
	+ if ((elm) == RB_LEFT(RB_PARENT(elm, field), field)) \
	+ RB_LEFT(RB_PARENT(elm, field), field) = (tmp); \
	+ else \
	+ RB_RIGHT(RB_PARENT(elm, field), field) = (tmp); \
	+ } else \
	+ (head)->rbh_root = (tmp); \
	+ RB_LEFT(tmp, field) = (elm); \
	+ RB_PARENT(elm, field) = (tmp); \
	+ RB_AUGMENT(tmp); \
	+ if ((RB_PARENT(tmp, field))) \
	+ RB_AUGMENT(RB_PARENT(tmp, field)); \
	+} while (0)
	+
	+#define RB_ROTATE_RIGHT(head, elm, tmp, field) do { \
	+ (tmp) = RB_LEFT(elm, field); \
	+ if ((RB_LEFT(elm, field) = RB_RIGHT(tmp, field))) { \
	+ RB_PARENT(RB_RIGHT(tmp, field), field) = (elm); \
	+ } \
	+ RB_AUGMENT(elm); \
	+ if ((RB_PARENT(tmp, field) = RB_PARENT(elm, field))) { \
	+ if ((elm) == RB_LEFT(RB_PARENT(elm, field), field)) \
	+ RB_LEFT(RB_PARENT(elm, field), field) = (tmp); \
	+ else \
	+ RB_RIGHT(RB_PARENT(elm, field), field) = (tmp); \
	+ } else \
	+ (head)->rbh_root = (tmp); \
	+ RB_RIGHT(tmp, field) = (elm); \
	+ RB_PARENT(elm, field) = (tmp); \
	+ RB_AUGMENT(tmp); \
	+ if ((RB_PARENT(tmp, field))) \
	+ RB_AUGMENT(RB_PARENT(tmp, field)); \
	+} while (0)
	+
	+/* Generates prototypes and inline functions */
	+#define RB_PROTOTYPE(name, type, field, cmp) \
	+ RB_PROTOTYPE_INTERNAL(name, type, field, cmp,)
	+#define RB_PROTOTYPE_STATIC(name, type, field, cmp) \
	+ RB_PROTOTYPE_INTERNAL(name, type, field, cmp, __attribute__((__unused__)) static)
	+#define RB_PROTOTYPE_INTERNAL(name, type, field, cmp, attr) \
	+attr void name##_RB_INSERT_COLOR(struct name , struct type ); \
	+attr void name##_RB_REMOVE_COLOR(struct name , struct type , struct type *);\
	+attr struct type name##_RB_REMOVE(struct name , struct type *); \
	+attr struct type name##_RB_INSERT(struct name , struct type *); \
	+attr struct type name##_RB_FIND(struct name , struct type *); \
	+attr struct type name##_RB_NFIND(struct name , struct type *); \
	+attr struct type name##_RB_NEXT(struct type ); \
	+attr struct type name##_RB_PREV(struct type ); \
	+attr struct type name##_RB_MINMAX(struct name , int); \
	+ \
	+
	+/* Main rb operation.
	+ * Moves node close to the key of elm to top
	+ */
	+#define RB_GENERATE(name, type, field, cmp) \
	+ RB_GENERATE_INTERNAL(name, type, field, cmp,)
	+#define RB_GENERATE_STATIC(name, type, field, cmp) \
	+ RB_GENERATE_INTERNAL(name, type, field, cmp, __attribute__((__unused__)) static)
	+#define RB_GENERATE_INTERNAL(name, type, field, cmp, attr) \
	+attr void \
	+name##_RB_INSERT_COLOR(struct name head, struct type elm) \
	+{ \
	+ struct type parent, gparent, *tmp; \
	+ while ((parent = RB_PARENT(elm, field)) && \
	+ RB_COLOR(parent, field) == RB_RED) { \
	+ gparent = RB_PARENT(parent, field); \
	+ if (parent == RB_LEFT(gparent, field)) { \
	+ tmp = RB_RIGHT(gparent, field); \
	+ if (tmp && RB_COLOR(tmp, field) == RB_RED) { \
	+ RB_COLOR(tmp, field) = RB_BLACK; \
	+ RB_SET_BLACKRED(parent, gparent, field);\
	+ elm = gparent; \
	+ continue; \
	+ } \
	+ if (RB_RIGHT(parent, field) == elm) { \
	+ RB_ROTATE_LEFT(head, parent, tmp, field);\
	+ tmp = parent; \
	+ parent = elm; \
	+ elm = tmp; \
	+ } \
	+ RB_SET_BLACKRED(parent, gparent, field); \
	+ RB_ROTATE_RIGHT(head, gparent, tmp, field); \
	+ } else { \
	+ tmp = RB_LEFT(gparent, field); \
	+ if (tmp && RB_COLOR(tmp, field) == RB_RED) { \
	+ RB_COLOR(tmp, field) = RB_BLACK; \
	+ RB_SET_BLACKRED(parent, gparent, field);\
	+ elm = gparent; \
	+ continue; \
	+ } \
	+ if (RB_LEFT(parent, field) == elm) { \
	+ RB_ROTATE_RIGHT(head, parent, tmp, field);\
	+ tmp = parent; \
	+ parent = elm; \
	+ elm = tmp; \
	+ } \
	+ RB_SET_BLACKRED(parent, gparent, field); \
	+ RB_ROTATE_LEFT(head, gparent, tmp, field); \
	+ } \
	+ } \
	+ RB_COLOR(head->rbh_root, field) = RB_BLACK; \
	+} \
	+ \
	+attr void \
	+name##_RB_REMOVE_COLOR(struct name head, struct type parent, struct type *elm) \
	+{ \
	+ struct type *tmp; \
	+ while ((elm == NULL \|\| RB_COLOR(elm, field) == RB_BLACK) && \
	+ elm != RB_ROOT(head)) { \
	+ if (RB_LEFT(parent, field) == elm) { \
	+ tmp = RB_RIGHT(parent, field); \
	+ if (RB_COLOR(tmp, field) == RB_RED) { \
	+ RB_SET_BLACKRED(tmp, parent, field); \
	+ RB_ROTATE_LEFT(head, parent, tmp, field);\
	+ tmp = RB_RIGHT(parent, field); \
	+ } \
	+ if ((RB_LEFT(tmp, field) == NULL \|\| \
	+ RB_COLOR(RB_LEFT(tmp, field), field) == RB_BLACK) &&\
	+ (RB_RIGHT(tmp, field) == NULL \|\| \
	+ RB_COLOR(RB_RIGHT(tmp, field), field) == RB_BLACK)) {\
	+ RB_COLOR(tmp, field) = RB_RED; \
	+ elm = parent; \
	+ parent = RB_PARENT(elm, field); \
	+ } else { \
	+ if (RB_RIGHT(tmp, field) == NULL \|\| \
	+ RB_COLOR(RB_RIGHT(tmp, field), field) == RB_BLACK) {\
	+ struct type *oleft; \
	+ if ((oleft = RB_LEFT(tmp, field)))\
	+ RB_COLOR(oleft, field) = RB_BLACK;\
	+ RB_COLOR(tmp, field) = RB_RED; \
	+ RB_ROTATE_RIGHT(head, tmp, oleft, field);\
	+ tmp = RB_RIGHT(parent, field); \
	+ } \
	+ RB_COLOR(tmp, field) = RB_COLOR(parent, field);\
	+ RB_COLOR(parent, field) = RB_BLACK; \
	+ if (RB_RIGHT(tmp, field)) \
	+ RB_COLOR(RB_RIGHT(tmp, field), field) = RB_BLACK;\
	+ RB_ROTATE_LEFT(head, parent, tmp, field);\
	+ elm = RB_ROOT(head); \
	+ break; \
	+ } \
	+ } else { \
	+ tmp = RB_LEFT(parent, field); \
	+ if (RB_COLOR(tmp, field) == RB_RED) { \
	+ RB_SET_BLACKRED(tmp, parent, field); \
	+ RB_ROTATE_RIGHT(head, parent, tmp, field);\
	+ tmp = RB_LEFT(parent, field); \
	+ } \
	+ if ((RB_LEFT(tmp, field) == NULL \|\| \
	+ RB_COLOR(RB_LEFT(tmp, field), field) == RB_BLACK) &&\
	+ (RB_RIGHT(tmp, field) == NULL \|\| \
	+ RB_COLOR(RB_RIGHT(tmp, field), field) == RB_BLACK)) {\
	+ RB_COLOR(tmp, field) = RB_RED; \
	+ elm = parent; \
	+ parent = RB_PARENT(elm, field); \
	+ } else { \
	+ if (RB_LEFT(tmp, field) == NULL \|\| \
	+ RB_COLOR(RB_LEFT(tmp, field), field) == RB_BLACK) {\
	+ struct type *oright; \
	+ if ((oright = RB_RIGHT(tmp, field)))\
	+ RB_COLOR(oright, field) = RB_BLACK;\
	+ RB_COLOR(tmp, field) = RB_RED; \
	+ RB_ROTATE_LEFT(head, tmp, oright, field);\
	+ tmp = RB_LEFT(parent, field); \
	+ } \
	+ RB_COLOR(tmp, field) = RB_COLOR(parent, field);\
	+ RB_COLOR(parent, field) = RB_BLACK; \
	+ if (RB_LEFT(tmp, field)) \
	+ RB_COLOR(RB_LEFT(tmp, field), field) = RB_BLACK;\
	+ RB_ROTATE_RIGHT(head, parent, tmp, field);\
	+ elm = RB_ROOT(head); \
	+ break; \
	+ } \
	+ } \
	+ } \
	+ if (elm) \
	+ RB_COLOR(elm, field) = RB_BLACK; \
	+} \
	+ \
	+attr struct type * \
	+name##_RB_REMOVE(struct name head, struct type elm) \
	+{ \
	+ struct type child, parent, *old = elm; \
	+ int color; \
	+ if (RB_LEFT(elm, field) == NULL) \
	+ child = RB_RIGHT(elm, field); \
	+ else if (RB_RIGHT(elm, field) == NULL) \
	+ child = RB_LEFT(elm, field); \
	+ else { \
	+ struct type *left; \
	+ elm = RB_RIGHT(elm, field); \
	+ while ((left = RB_LEFT(elm, field))) \
	+ elm = left; \
	+ child = RB_RIGHT(elm, field); \
	+ parent = RB_PARENT(elm, field); \
	+ color = RB_COLOR(elm, field); \
	+ if (child) \
	+ RB_PARENT(child, field) = parent; \
	+ if (parent) { \
	+ if (RB_LEFT(parent, field) == elm) \
	+ RB_LEFT(parent, field) = child; \
	+ else \
	+ RB_RIGHT(parent, field) = child; \
	+ RB_AUGMENT(parent); \
	+ } else \
	+ RB_ROOT(head) = child; \
	+ if (RB_PARENT(elm, field) == old) \
	+ parent = elm; \
	+ (elm)->field = (old)->field; \
	+ if (RB_PARENT(old, field)) { \
	+ if (RB_LEFT(RB_PARENT(old, field), field) == old)\
	+ RB_LEFT(RB_PARENT(old, field), field) = elm;\
	+ else \
	+ RB_RIGHT(RB_PARENT(old, field), field) = elm;\
	+ RB_AUGMENT(RB_PARENT(old, field)); \
	+ } else \
	+ RB_ROOT(head) = elm; \
	+ RB_PARENT(RB_LEFT(old, field), field) = elm; \
	+ if (RB_RIGHT(old, field)) \
	+ RB_PARENT(RB_RIGHT(old, field), field) = elm; \
	+ if (parent) { \
	+ left = parent; \
	+ do { \
	+ RB_AUGMENT(left); \
	+ } while ((left = RB_PARENT(left, field))); \
	+ } \
	+ goto color; \
	+ } \
	+ parent = RB_PARENT(elm, field); \
	+ color = RB_COLOR(elm, field); \
	+ if (child) \
	+ RB_PARENT(child, field) = parent; \
	+ if (parent) { \
	+ if (RB_LEFT(parent, field) == elm) \
	+ RB_LEFT(parent, field) = child; \
	+ else \
	+ RB_RIGHT(parent, field) = child; \
	+ RB_AUGMENT(parent); \
	+ } else \
	+ RB_ROOT(head) = child; \
	+color: \
	+ if (color == RB_BLACK) \
	+ name##_RB_REMOVE_COLOR(head, parent, child); \
	+ return (old); \
	+} \
	+ \
	+/* Inserts a node into the RB tree */ \
	+attr struct type * \
	+name##_RB_INSERT(struct name head, struct type elm) \
	+{ \
	+ struct type *tmp; \
	+ struct type *parent = NULL; \
	+ int comp = 0; \
	+ tmp = RB_ROOT(head); \
	+ while (tmp) { \
	+ parent = tmp; \
	+ comp = (cmp)(elm, parent); \
	+ if (comp < 0) \
	+ tmp = RB_LEFT(tmp, field); \
	+ else if (comp > 0) \
	+ tmp = RB_RIGHT(tmp, field); \
	+ else \
	+ return (tmp); \
	+ } \
	+ RB_SET(elm, parent, field); \
	+ if (parent != NULL) { \
	+ if (comp < 0) \
	+ RB_LEFT(parent, field) = elm; \
	+ else \
	+ RB_RIGHT(parent, field) = elm; \
	+ RB_AUGMENT(parent); \
	+ } else \
	+ RB_ROOT(head) = elm; \
	+ name##_RB_INSERT_COLOR(head, elm); \
	+ return (NULL); \
	+} \
	+ \
	+/* Finds the node with the same key as elm */ \
	+attr struct type * \
	+name##_RB_FIND(struct name head, struct type elm) \
	+{ \
	+ struct type *tmp = RB_ROOT(head); \
	+ int comp; \
	+ while (tmp) { \
	+ comp = cmp(elm, tmp); \
	+ if (comp < 0) \
	+ tmp = RB_LEFT(tmp, field); \
	+ else if (comp > 0) \
	+ tmp = RB_RIGHT(tmp, field); \
	+ else \
	+ return (tmp); \
	+ } \
	+ return (NULL); \
	+} \
	+ \
	+/* Finds the first node greater than or equal to the search key */ \
	+attr struct type * \
	+name##_RB_NFIND(struct name head, struct type elm) \
	+{ \
	+ struct type *tmp = RB_ROOT(head); \
	+ struct type *res = NULL; \
	+ int comp; \
	+ while (tmp) { \
	+ comp = cmp(elm, tmp); \
	+ if (comp < 0) { \
	+ res = tmp; \
	+ tmp = RB_LEFT(tmp, field); \
	+ } \
	+ else if (comp > 0) \
	+ tmp = RB_RIGHT(tmp, field); \
	+ else \
	+ return (tmp); \
	+ } \
	+ return (res); \
	+} \
	+ \
	+/* ARGSUSED */ \
	+attr struct type * \
	+name##_RB_NEXT(struct type *elm) \
	+{ \
	+ if (RB_RIGHT(elm, field)) { \
	+ elm = RB_RIGHT(elm, field); \
	+ while (RB_LEFT(elm, field)) \
	+ elm = RB_LEFT(elm, field); \
	+ } else { \
	+ if (RB_PARENT(elm, field) && \
	+ (elm == RB_LEFT(RB_PARENT(elm, field), field))) \
	+ elm = RB_PARENT(elm, field); \
	+ else { \
	+ while (RB_PARENT(elm, field) && \
	+ (elm == RB_RIGHT(RB_PARENT(elm, field), field)))\
	+ elm = RB_PARENT(elm, field); \
	+ elm = RB_PARENT(elm, field); \
	+ } \
	+ } \
	+ return (elm); \
	+} \
	+ \
	+/* ARGSUSED */ \
	+attr struct type * \
	+name##_RB_PREV(struct type *elm) \
	+{ \
	+ if (RB_LEFT(elm, field)) { \
	+ elm = RB_LEFT(elm, field); \
	+ while (RB_RIGHT(elm, field)) \
	+ elm = RB_RIGHT(elm, field); \
	+ } else { \
	+ if (RB_PARENT(elm, field) && \
	+ (elm == RB_RIGHT(RB_PARENT(elm, field), field))) \
	+ elm = RB_PARENT(elm, field); \
	+ else { \
	+ while (RB_PARENT(elm, field) && \
	+ (elm == RB_LEFT(RB_PARENT(elm, field), field)))\
	+ elm = RB_PARENT(elm, field); \
	+ elm = RB_PARENT(elm, field); \
	+ } \
	+ } \
	+ return (elm); \
	+} \
	+ \
	+attr struct type * \
	+name##_RB_MINMAX(struct name *head, int val) \
	+{ \
	+ struct type *tmp = RB_ROOT(head); \
	+ struct type *parent = NULL; \
	+ while (tmp) { \
	+ parent = tmp; \
	+ if (val < 0) \
	+ tmp = RB_LEFT(tmp, field); \
	+ else \
	+ tmp = RB_RIGHT(tmp, field); \
	+ } \
	+ return (parent); \
	+}
	+
	+#define RB_NEGINF -1
	+#define RB_INF 1
	+
	+#define RB_INSERT(name, x, y) name##_RB_INSERT(x, y)
	+#define RB_REMOVE(name, x, y) name##_RB_REMOVE(x, y)
	+#define RB_FIND(name, x, y) name##_RB_FIND(x, y)
	+#define RB_NFIND(name, x, y) name##_RB_NFIND(x, y)
	+#define RB_NEXT(name, x, y) name##_RB_NEXT(y)
	+#define RB_PREV(name, x, y) name##_RB_PREV(y)
	+#define RB_MIN(name, x) name##_RB_MINMAX(x, RB_NEGINF)
	+#define RB_MAX(name, x) name##_RB_MINMAX(x, RB_INF)
	+
	+#define RB_FOREACH(x, name, head) \
	+ for ((x) = RB_MIN(name, head); \
	+ (x) != NULL; \
	+ (x) = name##_RB_NEXT(x))
	+
	+#define RB_FOREACH_SAFE(x, name, head, y) \
	+ for ((x) = RB_MIN(name, head); \
	+ ((x) != NULL) && ((y) = name##_RB_NEXT(x), 1); \
	+ (x) = (y))
	+
	+#define RB_FOREACH_REVERSE(x, name, head) \
	+ for ((x) = RB_MAX(name, head); \
	+ (x) != NULL; \
	+ (x) = name##_RB_PREV(x))
	+
	+#define RB_FOREACH_REVERSE_SAFE(x, name, head, y) \
	+ for ((x) = RB_MAX(name, head); \
	+ ((x) != NULL) && ((y) = name##_RB_PREV(x), 1); \
	+ (x) = (y))
	+
	+#endif /* _SYS_TREE_H_ */
	Index: contrib/mg/tty.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/tty.c
	@@ -0,0 +1,459 @@
	+/* $OpenBSD: tty.c,v 1.39 2021/03/20 09:00:49 lum Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * Terminfo display driver
	+ *
	+ * Terminfo is a terminal information database and routines to describe
	+ * terminals on most modern UNIX systems. Many other systems have adopted
	+ * this as a reasonable way to allow for widely varying and ever changing
	+ * varieties of terminal types. This should be used where practical.
	+ */
	+/*
	+ * Known problems: If you have a terminal with no clear to end of screen and
	+ * memory of lines below the ones visible on the screen, display will be
	+ * wrong in some cases. I doubt that any such terminal was ever made, but I
	+ * thought everyone with delete line would have clear to end of screen too...
	+ *
	+ * Code for terminals without clear to end of screen and/or clear to end of line
	+ * has not been extensively tested.
	+ *
	+ * Cost calculations are very rough. Costs of insert/delete line may be far
	+ * from the truth. This is accentuated by display.c not knowing about
	+ * multi-line insert/delete.
	+ *
	+ * Using scrolling region vs insert/delete line should probably be based on cost
	+ * rather than the assumption that scrolling region operations look better.
	+ */
	+
	+#include <sys/ioctl.h>
	+#include <sys/queue.h>
	+#include <sys/types.h>
	+#include <sys/time.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <term.h>
	+#include <unistd.h>
	+
	+#include "def.h"
	+
	+static int charcost(const char *);
	+
	+static int cci;
	+static int insdel; /* Do we have both insert & delete line? */
	+static char scroll_fwd; / How to scroll forward. */
	+
	+static void winchhandler(int);
	+
	+volatile sig_atomic_t winch_flag;
	+int tceeol;
	+int tcinsl;
	+int tcdell;
	+
	+/* ARGSUSED */
	+static void
	+winchhandler(int sig)
	+{
	+ winch_flag = 1;
	+}
	+
	+/*
	+ * Initialize the terminal when the editor
	+ * gets started up.
	+ */
	+void
	+ttinit(void)
	+{
	+ char *tty;
	+ int errret;
	+
	+ if (batch == 1)
	+ tty = "pty";
	+ else
	+ tty = NULL;
	+
	+ if (setupterm(tty, STDOUT_FILENO, &errret))
	+ panic("Terminal setup failed");
	+
	+ signal(SIGWINCH, winchhandler);
	+ signal(SIGCONT, winchhandler);
	+ siginterrupt(SIGWINCH, 1);
	+
	+ scroll_fwd = scroll_forward;
	+ if (scroll_fwd == NULL \|\| *scroll_fwd == '\0') {
	+ /* this is what GNU Emacs does */
	+ scroll_fwd = parm_down_cursor;
	+ if (scroll_fwd == NULL \|\| *scroll_fwd == '\0')
	+ scroll_fwd = curbp->b_nlchr;
	+ }
	+
	+ if (cursor_address == NULL \|\| cursor_up == NULL)
	+ panic("This terminal is too stupid to run mg");
	+
	+ /* set nrow & ncol */
	+ ttresize();
	+
	+ if (!clr_eol)
	+ tceeol = ncol;
	+ else
	+ tceeol = charcost(clr_eol);
	+
	+ /* Estimate cost of inserting a line */
	+ if (change_scroll_region && scroll_reverse)
	+ tcinsl = charcost(change_scroll_region) * 2 +
	+ charcost(scroll_reverse);
	+ else if (parm_insert_line)
	+ tcinsl = charcost(parm_insert_line);
	+ else if (insert_line)
	+ tcinsl = charcost(insert_line);
	+ else
	+ /* make this cost high enough */
	+ tcinsl = nrow * ncol;
	+
	+ /* Estimate cost of deleting a line */
	+ if (change_scroll_region)
	+ tcdell = charcost(change_scroll_region) * 2 +
	+ charcost(scroll_fwd);
	+ else if (parm_delete_line)
	+ tcdell = charcost(parm_delete_line);
	+ else if (delete_line)
	+ tcdell = charcost(delete_line);
	+ else
	+ /* make this cost high enough */
	+ tcdell = nrow * ncol;
	+
	+ /* Flag to indicate that we can both insert and delete lines */
	+ insdel = (insert_line \|\| parm_insert_line) &&
	+ (delete_line \|\| parm_delete_line);
	+
	+ if (enter_ca_mode)
	+ /* enter application mode */
	+ putpad(enter_ca_mode, 1);
	+
	+ ttresize();
	+}
	+
	+/*
	+ * Re-initialize the terminal when the editor is resumed.
	+ * The keypad_xmit doesn't really belong here but...
	+ */
	+void
	+ttreinit(void)
	+{
	+ /* check if file was modified while we were gone */
	+ if (fchecktime(curbp) != TRUE) {
	+ curbp->b_flag \|= BFDIRTY;
	+ }
	+
	+ if (enter_ca_mode)
	+ /* enter application mode */
	+ putpad(enter_ca_mode, 1);
	+
	+ if (keypad_xmit)
	+ /* turn on keypad */
	+ putpad(keypad_xmit, 1);
	+
	+ ttresize();
	+}
	+
	+/*
	+ * Clean up the terminal, in anticipation of a return to the command
	+ * interpreter. This is a no-op on the ANSI display. On the SCALD display,
	+ * it sets the window back to half screen scrolling. Perhaps it should
	+ * query the display for the increment, and put it back to what it was.
	+ */
	+void
	+tttidy(void)
	+{
	+ ttykeymaptidy();
	+
	+ /* set the term back to normal mode */
	+ if (exit_ca_mode)
	+ putpad(exit_ca_mode, 1);
	+}
	+
	+/*
	+ * Move the cursor to the specified origin 0 row and column position. Try to
	+ * optimize out extra moves; redisplay may have left the cursor in the right
	+ * location last time!
	+ */
	+void
	+ttmove(int row, int col)
	+{
	+ if (ttrow != row \|\| ttcol != col) {
	+ putpad(tgoto(cursor_address, col, row), 1);
	+ ttrow = row;
	+ ttcol = col;
	+ }
	+}
	+
	+/*
	+ * Erase to end of line.
	+ */
	+void
	+tteeol(void)
	+{
	+ int i;
	+
	+ if (clr_eol)
	+ putpad(clr_eol, 1);
	+ else {
	+ i = ncol - ttcol;
	+ while (i--)
	+ ttputc(' ');
	+ ttrow = ttcol = HUGE;
	+ }
	+}
	+
	+/*
	+ * Erase to end of page.
	+ */
	+void
	+tteeop(void)
	+{
	+ int line;
	+
	+ if (clr_eos)
	+ putpad(clr_eos, nrow - ttrow);
	+ else {
	+ putpad(clr_eol, 1);
	+ if (insdel)
	+ ttdell(ttrow + 1, lines, lines - ttrow - 1);
	+ else {
	+ /* do it by hand */
	+ for (line = ttrow + 1; line <= lines; ++line) {
	+ ttmove(line, 0);
	+ tteeol();
	+ }
	+ }
	+ ttrow = ttcol = HUGE;
	+ }
	+}
	+
	+/*
	+ * Make a noise.
	+ */
	+void
	+ttbeep(void)
	+{
	+ putpad(bell, 1);
	+ ttflush();
	+}
	+
	+/*
	+ * Insert nchunk blank line(s) onto the screen, scrolling the last line on
	+ * the screen off the bottom. Use the scrolling region if possible for a
	+ * smoother display. If there is no scrolling region, use a set of insert
	+ * and delete line sequences.
	+ */
	+void
	+ttinsl(int row, int bot, int nchunk)
	+{
	+ int i, nl;
	+
	+ /* One line special cases */
	+ if (row == bot) {
	+ ttmove(row, 0);
	+ tteeol();
	+ return;
	+ }
	+ /* Use scroll region and back index */
	+ if (change_scroll_region && scroll_reverse) {
	+ nl = bot - row;
	+ ttwindow(row, bot);
	+ ttmove(row, 0);
	+ while (nchunk--)
	+ putpad(scroll_reverse, nl);
	+ ttnowindow();
	+ return;
	+ /* else use insert/delete line */
	+ } else if (insdel) {
	+ ttmove(1 + bot - nchunk, 0);
	+ nl = nrow - ttrow;
	+ if (parm_delete_line)
	+ putpad(tgoto(parm_delete_line, 0, nchunk), nl);
	+ else
	+ /* For all lines in the chunk */
	+ for (i = 0; i < nchunk; i++)
	+ putpad(delete_line, nl);
	+ ttmove(row, 0);
	+
	+ /* ttmove() changes ttrow */
	+ nl = nrow - ttrow;
	+
	+ if (parm_insert_line)
	+ putpad(tgoto(parm_insert_line, 0, nchunk), nl);
	+ else
	+ /* For all lines in the chunk */
	+ for (i = 0; i < nchunk; i++)
	+ putpad(insert_line, nl);
	+ ttrow = HUGE;
	+ ttcol = HUGE;
	+ } else
	+ panic("ttinsl: Can't insert/delete line");
	+}
	+
	+/*
	+ * Delete nchunk line(s) from "row", replacing the bottom line on the
	+ * screen with a blank line. Unless we're using the scrolling region,
	+ * this is done with crafty sequences of insert and delete lines. The
	+ * presence of the echo area makes a boundary condition go away.
	+ */
	+void
	+ttdell(int row, int bot, int nchunk)
	+{
	+ int i, nl;
	+
	+ /* One line special cases */
	+ if (row == bot) {
	+ ttmove(row, 0);
	+ tteeol();
	+ return;
	+ }
	+ /* scrolling region */
	+ if (change_scroll_region) {
	+ nl = bot - row;
	+ ttwindow(row, bot);
	+ ttmove(bot, 0);
	+ while (nchunk--)
	+ putpad(scroll_fwd, nl);
	+ ttnowindow();
	+ /* else use insert/delete line */
	+ } else if (insdel) {
	+ ttmove(row, 0);
	+ nl = nrow - ttrow;
	+ if (parm_delete_line)
	+ putpad(tgoto(parm_delete_line, 0, nchunk), nl);
	+ else
	+ /* For all lines in the chunk */
	+ for (i = 0; i < nchunk; i++)
	+ putpad(delete_line, nl);
	+ ttmove(1 + bot - nchunk, 0);
	+
	+ /* ttmove() changes ttrow */
	+ nl = nrow - ttrow;
	+
	+ if (parm_insert_line)
	+ putpad(tgoto(parm_insert_line, 0, nchunk), nl);
	+ else
	+ /* For all lines in the chunk */
	+ for (i = 0; i < nchunk; i++)
	+ putpad(insert_line, nl);
	+ ttrow = HUGE;
	+ ttcol = HUGE;
	+ } else
	+ panic("ttdell: Can't insert/delete line");
	+}
	+
	+/*
	+ * This routine sets the scrolling window on the display to go from line
	+ * "top" to line "bot" (origin 0, inclusive). The caller checks for the
	+ * pathological 1-line scroll window which doesn't work right and avoids
	+ * it. The "ttrow" and "ttcol" variables are set to a crazy value to
	+ * ensure that the next call to "ttmove" does not turn into a no-op (the
	+ * window adjustment moves the cursor).
	+ */
	+void
	+ttwindow(int top, int bot)
	+{
	+ if (change_scroll_region && (tttop != top \|\| ttbot != bot)) {
	+ putpad(tgoto(change_scroll_region, bot, top), nrow - ttrow);
	+ ttrow = HUGE; /* Unknown. */
	+ ttcol = HUGE;
	+ tttop = top; /* Remember region. */
	+ ttbot = bot;
	+ }
	+}
	+
	+/*
	+ * Switch to full screen scroll. This is used by "spawn.c" just before it
	+ * suspends the editor and by "display.c" when it is getting ready to
	+ * exit. This function does a full screen scroll by telling the terminal
	+ * to set a scrolling region that is lines or nrow rows high, whichever is
	+ * larger. This behavior seems to work right on systems where you can set
	+ * your terminal size.
	+ */
	+void
	+ttnowindow(void)
	+{
	+ if (change_scroll_region) {
	+ putpad(tgoto(change_scroll_region,
	+ (nrow > lines ? nrow : lines) - 1, 0), nrow - ttrow);
	+ ttrow = HUGE; /* Unknown. */
	+ ttcol = HUGE;
	+ tttop = HUGE; /* No scroll region. */
	+ ttbot = HUGE;
	+ }
	+}
	+
	+/*
	+ * Set the current writing color to the specified color. Watch for color
	+ * changes that are not going to do anything (the color is already right)
	+ * and don't send anything to the display. The rainbow version does this
	+ * in putline.s on a line by line basis, so don't bother sending out the
	+ * color shift.
	+ */
	+void
	+ttcolor(int color)
	+{
	+ if (color != tthue) {
	+ if (color == CTEXT)
	+ /* normal video */
	+ putpad(exit_standout_mode, 1);
	+ else if (color == CMODE)
	+ /* reverse video */
	+ putpad(enter_standout_mode, 1);
	+ /* save the color */
	+ tthue = color;
	+ }
	+}
	+
	+/*
	+ * This routine is called by the "refresh the screen" command to try
	+ * to resize the display. Look in "window.c" to see how
	+ * the caller deals with a change.
	+ *
	+ * We use `newrow' and `newcol' so vtresize() know the difference between the
	+ * new and old settings.
	+ */
	+void
	+ttresize(void)
	+{
	+ int newrow = 0, newcol = 0;
	+
	+ struct winsize winsize;
	+
	+ if (ioctl(0, TIOCGWINSZ, &winsize) == 0) {
	+ newrow = winsize.ws_row;
	+ newcol = winsize.ws_col;
	+ }
	+ if ((newrow <= 0 \|\| newcol <= 0) &&
	+ ((newrow = lines) <= 0 \|\| (newcol = columns) <= 0)) {
	+ newrow = 24;
	+ newcol = 80;
	+ }
	+ if (vtresize(1, newrow, newcol) != TRUE)
	+ panic("vtresize failed");
	+}
	+
	+/*
	+ * fake char output for charcost()
	+ */
	+/* ARGSUSED */
	+static int
	+fakec(int c)
	+{
	+ cci++;
	+ return (0);
	+}
	+
	+/* calculate the cost of doing string s */
	+static int
	+charcost(const char *s)
	+{
	+ cci = 0;
	+
	+ tputs(s, nrow, fakec);
	+ return (cci);
	+}
	Index: contrib/mg/ttyio.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/ttyio.c
	@@ -0,0 +1,228 @@
	+/* $OpenBSD: ttyio.c,v 1.40 2021/03/20 09:00:49 lum Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * POSIX terminal I/O.
	+ *
	+ * The functions in this file negotiate with the operating system for
	+ * keyboard characters, and write characters to the display in a barely
	+ * buffered fashion.
	+ */
	+
	+#include <sys/ioctl.h>
	+#include <sys/queue.h>
	+#include <sys/time.h>
	+#include <sys/types.h>
	+#include <errno.h>
	+#include <fcntl.h>
	+#include <poll.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+#include <term.h>
	+#include <termios.h>
	+#include <unistd.h>
	+
	+#include "def.h"
	+
	+#define NOBUF 512 /* Output buffer size. */
	+
	+int ttstarted;
	+char obuf[NOBUF]; /* Output buffer. */
	+size_t nobuf; /* Buffer count. */
	+struct termios oldtty; /* POSIX tty settings. */
	+struct termios newtty;
	+int nrow; /* Terminal size, rows. */
	+int ncol; /* Terminal size, columns. */
	+
	+/*
	+ * This function gets called once, to set up the terminal.
	+ * On systems w/o TCSASOFT we turn off off flow control,
	+ * which isn't really the right thing to do.
	+ */
	+void
	+ttopen(void)
	+{
	+ if (!isatty(STDIN_FILENO) \|\| !isatty(STDOUT_FILENO))
	+ panic("standard input and output must be a terminal");
	+
	+ if (ttraw() == FALSE)
	+ panic("aborting due to terminal initialize failure");
	+}
	+
	+/*
	+ * This function sets the terminal to RAW mode, as defined for the current
	+ * shell. This is called both by ttopen() above and by spawncli() to
	+ * get the current terminal settings and then change them to what
	+ * mg expects. Thus, tty changes done while spawncli() is in effect
	+ * will be reflected in mg.
	+ */
	+int
	+ttraw(void)
	+{
	+ if (tcgetattr(0, &oldtty) == -1) {
	+ dobeep();
	+ ewprintf("ttopen can't get terminal attributes");
	+ return (FALSE);
	+ }
	+ (void)memcpy(&newtty, &oldtty, sizeof(newtty));
	+ /* Set terminal to 'raw' mode and ignore a 'break' */
	+ newtty.c_cc[VMIN] = 1;
	+ newtty.c_cc[VTIME] = 0;
	+ newtty.c_iflag \|= IGNBRK;
	+ newtty.c_iflag &= ~(BRKINT \| PARMRK \| INLCR \| IGNCR \| ICRNL \| IXON);
	+ newtty.c_oflag &= ~OPOST;
	+ newtty.c_lflag &= ~(ECHO \| ECHONL \| ICANON \| ISIG \| IEXTEN);
	+
	+ if (tcsetattr(0, TCSASOFT \| TCSADRAIN, &newtty) == -1) {
	+ dobeep();
	+ ewprintf("ttopen can't tcsetattr");
	+ return (FALSE);
	+ }
	+ ttstarted = 1;
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * This function gets called just before we go back home to the shell.
	+ * Put all of the terminal parameters back.
	+ * Under UN*X this just calls ttcooked(), but the ttclose() hook is in
	+ * because vttidy() in display.c expects it for portability reasons.
	+ */
	+void
	+ttclose(void)
	+{
	+ if (ttstarted) {
	+ if (ttcooked() == FALSE)
	+ panic(""); /* ttcooked() already printf'd */
	+ ttstarted = 0;
	+ }
	+}
	+
	+/*
	+ * This function restores all terminal settings to their default values,
	+ * in anticipation of exiting or suspending the editor.
	+ */
	+int
	+ttcooked(void)
	+{
	+ ttflush();
	+ if (tcsetattr(0, TCSASOFT \| TCSADRAIN, &oldtty) == -1) {
	+ dobeep();
	+ ewprintf("ttclose can't tcsetattr");
	+ return (FALSE);
	+ }
	+ return (TRUE);
	+}
	+
	+/*
	+ * Write character to the display. Characters are buffered up,
	+ * to make things a little bit more efficient.
	+ */
	+int
	+ttputc(int c)
	+{
	+ if (nobuf >= NOBUF)
	+ ttflush();
	+ obuf[nobuf++] = c;
	+ return (c);
	+}
	+
	+/*
	+ * Flush output.
	+ */
	+void
	+ttflush(void)
	+{
	+ ssize_t written;
	+ char *buf = obuf;
	+
	+ if (nobuf == 0 \|\| batch == 1)
	+ return;
	+
	+ while ((written = write(fileno(stdout), buf, nobuf)) != nobuf) {
	+ if (written == -1) {
	+ if (errno == EINTR)
	+ continue;
	+ panic("ttflush write failed");
	+ }
	+ buf += written;
	+ nobuf -= written;
	+ }
	+ nobuf = 0;
	+}
	+
	+/*
	+ * Read character from terminal. All 8 bits are returned, so that you
	+ * can use a multi-national terminal.
	+ */
	+int
	+ttgetc(void)
	+{
	+ char c;
	+ ssize_t ret;
	+
	+ do {
	+ ret = read(STDIN_FILENO, &c, 1);
	+ if (ret == -1 && errno == EINTR) {
	+ if (winch_flag) {
	+ redraw(0, 0);
	+ winch_flag = 0;
	+ }
	+ } else if (ret == -1 && errno == EIO)
	+ panic("lost stdin");
	+ else if (ret == 1)
	+ break;
	+ } while (1);
	+ return ((int) c) & 0xFF;
	+}
	+
	+/*
	+ * Returns TRUE if there are characters waiting to be read.
	+ */
	+int
	+charswaiting(void)
	+{
	+ int x;
	+
	+ return ((ioctl(0, FIONREAD, &x) == -1) ? 0 : x);
	+}
	+
	+/*
	+ * panic - just exit, as quickly as we can.
	+ */
	+void
	+panic(char *s)
	+{
	+ static int panicking = 0;
	+
	+ if (panicking)
	+ return;
	+ else
	+ panicking = 1;
	+ ttclose();
	+ (void) fputs("panic: ", stderr);
	+ (void) fputs(s, stderr);
	+ (void) fputc('\n', stderr); /* Use '\n' as no buffers now. */
	+ exit(1);
	+}
	+
	+/*
	+ * This function returns FALSE if any characters have showed up on the
	+ * tty before 'msec' milliseconds.
	+ */
	+int
	+ttwait(int msec)
	+{
	+ struct pollfd pfd[1];
	+
	+ pfd[0].fd = 0;
	+ pfd[0].events = POLLIN;
	+
	+ if ((poll(pfd, 1, msec)) == 0)
	+ return (TRUE);
	+ return (FALSE);
	+}
	Index: contrib/mg/ttykbd.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/ttykbd.c
	@@ -0,0 +1,80 @@
	+/* $OpenBSD: ttykbd.c,v 1.20 2021/02/23 08:10:51 lum Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * Name: MG 2a
	+ * Terminfo keyboard driver using key files
	+ * Created: 22-Nov-1987 Mic Kaczmarczik (mic@emx.cc.utexas.edu)
	+ */
	+
	+#include <sys/queue.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <term.h>
	+
	+#include "def.h"
	+#include "kbd.h"
	+
	+/*
	+ * Get keyboard character. Very simple if you use keymaps and keys files.
	+ */
	+
	+char *keystrings[] = {NULL};
	+
	+/*
	+ * Turn on function keys using keypad_xmit, then load a keys file, if
	+ * available. The keys file is located in the same manner as the startup
	+ * file is, depending on what startupfile() does on your system.
	+ */
	+void
	+ttykeymapinit(void)
	+{
	+ char *cp;
	+
	+ /* Bind keypad function keys. */
	+ if (key_left)
	+ dobindkey(fundamental_map, "backward-char", key_left);
	+ if (key_right)
	+ dobindkey(fundamental_map, "forward-char", key_right);
	+ if (key_up)
	+ dobindkey(fundamental_map, "previous-line", key_up);
	+ if (key_down)
	+ dobindkey(fundamental_map, "next-line", key_down);
	+ if (key_beg)
	+ dobindkey(fundamental_map, "beginning-of-line", key_beg);
	+ else if (key_home)
	+ dobindkey(fundamental_map, "beginning-of-line", key_home);
	+ if (key_end)
	+ dobindkey(fundamental_map, "end-of-line", key_end);
	+ if (key_npage)
	+ dobindkey(fundamental_map, "scroll-up", key_npage);
	+ if (key_ppage)
	+ dobindkey(fundamental_map, "scroll-down", key_ppage);
	+ if (key_ic)
	+ dobindkey(fundamental_map, "overwrite-mode", key_ic);
	+ if (key_dc)
	+ dobindkey(fundamental_map, "delete-char", key_dc);
	+
	+ if ((cp = getenv("TERM"))) {
	+ if (((cp = startupfile(cp, NULL)) != NULL) &&
	+ (load(cp) != TRUE))
	+ ewprintf("Error reading key initialization file");
	+ }
	+ if (keypad_xmit)
	+ /* turn on keypad */
	+ putpad(keypad_xmit, 1);
	+}
	+
	+/*
	+ * Clean up the keyboard -- called by tttidy()
	+ */
	+void
	+ttykeymaptidy(void)
	+{
	+ if (keypad_local)
	+ /* turn off keypad */
	+ putpad(keypad_local, 1);
	+}
	+
	Index: contrib/mg/tutorial
	===================================================================
	--- /dev/null
	+++ contrib/mg/tutorial
	@@ -0,0 +1,356 @@
	+The mg Tutorial
	+---------------
	+
	+The mg editor is a public domain editor intended to loosely resemble GNU Emacs,
	+while still retaining fast speed and a small memory footprint.
	+
	+Most mg commands involve using the Control (sometimes labelled "Ctrl") or the
	+Meta (sometimes labelled "Alt") key. We will use the following conventions in
	+this tutorial:
	+
	+ C-<chr> means hold down the Control key while typing the character <chr>.
	+ M-<chr> means hold down the Meta key while typing the character <chr>.
	+
	+If you don't have a Meta key, you can use Esc instead. Press and release the
	+Esc key and type <chr>. This is equivalent to M-<chr>.
	+
	+The first thing to learn is how to move up and down a document. To move your
	+cursor down a line, use the down-arrow cursor key or C-n (Control and n).
	+
	+>> Now type C-n multiple times and move your cursor past this line.
	+
	+Congratulations. You have now learned how to move your cursor down. To move
	+your cursor up one line, you can use the up-arrow cursor key or C-p (Control
	+and p).
	+
	+>> Try using C-p and C-n to move up and down and then move past this line.
	+
	+The next commands to learn are how to move your cursor left and right. To do
	+this, you can use the left-arrow and right-arrow cursor keys. Alternatively,
	+you can use C-b and C-f to do this.
	+
	+>> Practise using the arrow keys or C-b and C-f on this line.
	+
	+To make it easy to remember these commands, it helps to remember by letter:
	+P - Previous line, N - Next line, B - Backwards and F - Forward.
	+
	+Now that you've learned how to move single characters at a time, next we learn
	+how to move one word at a time. To do this, you can use M-f (Meta and f) or
	+M-b (Meta and b) to move forwards and backwards, one word at a time.
	+
	+>> Try moving one word at a time by using M-f and M-b on this line.
	+
	+Notice how the Ctrl and Meta key combinations perform related functions. C-f
	+moves one letter forward, whereas M-f moves one word forward. There are many
	+key combinations in mg, where C-<chr> will perform one function and M-<chr>
	+will perform a similar related function.
	+
	+Most probably by now you have moved passed the bottom of the text which was
	+initially shown to you when you opened this document. mg redraws your terminal
	+screen so that the cursor is in the middle. This is a feature of mg, which
	+allows you to see the lines before and after the current cursor position. The
	+same effect can be achieved manually.
	+
	+>> Now move the cursor down to this line and then type C-l (that's Control and
	+ lowercase L).
	+
	+Note that C-l refreshes the screen and centers it on the line you typed it on.
	+
	+To move to the beginning or end of a line, you can use the Home and End keys,
	+or you can use C-a and C-e to move to the beginning and end.
	+
	+>> Use C-a and C-e to move to the beginning and end of this line.
	+
	+The next commands we will learn is how to move up and down, one page at a time.
	+To do this, you can use the Page Up (sometimes labelled PgUp) and Page Down
	+(sometimes labelled PgDn) keys. You can also use C-v and M-v to do this. C-v
	+moves the cursor down one page and M-v moves it up one page.
	+
	+>> Try using M-v and C-v to move up and down, one page at a time.
	+
	+The final two motion commands we will learn are M-< (Meta-Less than) and
	+M-> (Meta-Greater than) which move you to the beginning and end of a file,
	+respectively. You may not want to try that now as you will probably lose your
	+place in this tutorial. Note that on most terminals, < is above the , key, so
	+you'll need to press the Shift key to type <.
	+
	+Movement Summary
	+-----------------
	+
	+The following is a summary of the movement commands we've learned so far:
	+
	+ C-f Move forward one character (can also use right arrow key).
	+ C-b Move backward one character (can also use left arrow key).
	+ C-p Move up one line (can also use up arrow key).
	+ C-n Move down one line (can also use down arrow key).
	+ M-f Move forward one word.
	+ M-b Move backward one word.
	+ C-a Move to beginning of line (can also use Home key).
	+ C-e Move to end of line (can also use End key).
	+ C-v Move forward one page (can also use PgDn/Page Down key).
	+ M-v Move backward one page (can also use PgUp/Page Up key).
	+ M-< Move to beginning of file.
	+ M-> Move to end of file.
	+
	+Now that you've mastered the basics of moving around in mg, you can cause mg
	+to execute these commands multiple times. The way to do this is to type C-u
	+followed by some digits followed by a movement command.
	+
	+>> Type C-u 5 C-f to move forward 5 characters.
	+
	+In general, C-u allows you to execute any command multiple times, not just
	+cursor motion commands. The only exception to this rule are C-v and M-v.
	+When using these two commands with an argument, they move the cursor by that
	+many lines instead of pages.
	+
	+Cancelling mg Commands
	+----------------------
	+
	+If you have started typing out a command that you didn't mean to finish, you
	+can use the C-g command to cancel the command immediately.
	+
	+>> For example, type C-u 50 and then type C-g to cancel the C-u command.
	+>> Type Esc and then C-g to cancel the Esc key.
	+
	+In general, you can use C-g to stop any mg commands. You may type it multiple
	+times if you wish. You should see the word "Quit" appear in the bottom of the
	+screen when you type C-g indicating that a command was cancelled.
	+
	+In general, when in doubt, use C-g to get out of trouble.
	+
	+Inserting/Deleting Text
	+-----------------------
	+
	+To insert text anywhere, simply move your cursor to the appropriate position
	+and begin typing. To delete characters, use the backspace key. If you use
	+M-<backspace> (Meta and backspace key), you will delete one word instead
	+of one character at a time.
	+
	+To delete characters to the right of the cursor, you can use C-d to delete
	+characters to the right of the current position. If you use M-d instead of
	+C-d, you can delete one word at a time instead of one character at a time.
	+
	+>> Try inserting and deleting characters and words on this line.
	+
	+Note that if you type too many characters on a single line, the line will
	+scroll off the screen and you will see a $ on the line to indicate that the
	+line is too long to fit on the screen at one time.
	+
	+To delete a line at a time, you can use C-k to kill the line from the current
	+cursor position to the end of the line. You can type C-k multiple times to
	+kill many lines.
	+
	+You can issue insert or delete commands multiple times using C-u. For example,
	+C-u 10 e will type out eeeeeeeeee, C-u 4 M-d will delete four words to the
	+right of the cursor and so on.
	+
	+To undo any operation, you can use C-_ (that's control-underscore).
	+
	+Now if you kill something that you didn't mean to, you can yank it back from
	+the dead by using C-y. In general, when you kill something bigger than a single
	+character, mg saves it in a buffer somewhere and you can restore it by using
	+C-y. This is useful for moving text around. You can kill text in one place,
	+move your cursor to the new location and then use C-y to paste it there.
	+
	+Search for Text
	+---------------
	+
	+To search for text, type C-s followed by the text you wish to search for. Note
	+that as you start typing the characters, mg automatically searches as you type
	+the characters.
	+
	+To continue searching the text you're looking for, type C-s to find the next
	+instance. To search in reverse, type C-r instead of C-s. If you type C-s or
	+C-r twice, it will simply search for the last text that you searched for.
	+
	+To stop searching for text, simply use the cursor keys (or C-f, C-b etc.) or
	+C-g to stop the search operation.
	+
	+>> Use C-s foo to search for "foo" in the text. You can use C-s again to
	+ find other instances of foo in the file.
	+
	+Note that if a word cannot be found, it will say Failing I-search: at the
	+bottom of the screen. Typing C-s again will wrap the search around from the
	+top of the file and begin searching from there.
	+
	+Replace Text
	+------------
	+
	+To replace text, use M-%. You will be prompted for the text to search for and
	+the text to replace it with. You will then be taken to the first instance of
	+text from the current position. At this point you can do one of the following:
	+
	+ y - Replace the text at this instance and search for more items.
	+ n - Skip this instance and search for more items.
	+ . or Enter - Stop replacing text (you can also use C-g).
	+ ! - Replace all the instances without prompting at each one.
	+
	+>> Try replacing "frobnitz" with "zutwalt" on this line.
	+
	+Cut/Copy/Paste Text
	+-------------------
	+
	+As explained above, you can cut regions using C-k to kill multiple lines. To
	+paste the text that you just cut, simply move your cursor to the point and
	+then type C-y to restore the text. You may type C-y multiple times to restore
	+the text. Hence, to copy text, you can use C-k to kill all the lines, use C-y
	+to restore it immediately, then move to the region you want to copy it to and
	+then type C-y again to restore the last cut text block again.
	+
	+Another way to cut or copy chunks of text is to first position your cursor at
	+the starting point of the chunk of text. Then type C-<space> to mark this as
	+the starting point to cut or copy. Then move the cursor to the end point of the
	+text chunk that you wish to manipulate. Then type C-w to cut the region, or
	+M-w to copy the region. If you wish to cancel marking a block of text, simply
	+type C-g to cancel the operation.
	+
	+To paste the region that you've cut or copied above, simply move your cursor
	+to the desired location and then type C-y to paste it.
	+
	+Status Line
	+-----------
	+
	+At the bottom of your screen is a reverse highlighted line. This is the status
	+line and lets you know some useful information about the file you're editing.
	+
	+On the status line, you should see "Mg: tutorial". This lets you know that
	+you're editing a file named "tutorial". If you've edited this file and not
	+saved it, it should have a "**" to the left of those words. If this file is
	+read-only, you should see a "%%" to the left of those words.
	+
	+To the right of the status line, you should see L followed by digits
	+and, if column-number-mode is enabled, C followed by some more digits.
	+Type M-x column-number-mode Enter to enable it if it is disabled (the
	+default). These indicate the line number and column number of the file
	+that your cursor is currently on. If you move the cursor around, you
	+should see the line and column number change.
	+
	+In the middle of the screen, you should see the word "(fundamental)" which
	+indicates that the current editing mode is "fundamental-mode". The mg editor
	+also supports a c-mode that is more suited to editing C code. There are also
	+some other useful editing modes for different situations. See the man page
	+for mg(1) to learn about the various editing modes.
	+
	+Opening and Saving Files
	+------------------------
	+
	+To open a file, you can use C-x C-f. You will then be prompted for a file name.
	+If you type a file name that doesn't already exist, a new file will be opened
	+for you. If the file name already exists, then it will be opened for you and
	+you can begin editing it. Note that you do not need to type the whole file
	+name for an existing file. You can type part of the file name and then press
	+the TAB key. If there is only file name that matches, mg will fill in the rest
	+of the file name for you. If there are multiple files, mg will display that
	+the choice is ambiguous. If you type the TAB key again, mg will show you all
	+the available choices for file names.
	+
	+NOTE: If you type C-x f instead of C-x C-f, you can use C-g to cancel the
	+Set-Fill-Column command. You can also use C-g to cancel the C-x C-f command
	+if you don't wish to open a new file.
	+
	+To save the file once you've edited it, use C-x C-s to save the file. When
	+mg is done saving the file, you should see the words "Wrote /path/to/file"
	+in the bottom of your screen. In general, it is a good idea to save quite
	+often. When you save a file, mg saves a backup of the file with a tilde (~)
	+character at the end.
	+
	+If you decide to open a directory instead of a file, mg will transistion into a
	+mode called dired. Dired fills a buffer with the contents of the selected
	+directory, one file or sub-directory's details per line. Some basic file
	+management functions can be performed on the files and sub-directories in the
	+buffer. For example, with the cursor over a specific file:
	+
	+ Pressing c will give you the opportunity to copy the file.
	+ Pressing d will mark the file for deletion.
	+ Pressing x will unlink files previously marked for deletion.
	+ Pressing Return will open the highlighted file into it's own buffer for
	+ editing.
	+
	+There are more dired commands, see the man page for further information.
	+
	+Working with Buffers and Windows
	+--------------------------------
	+
	+Once a file is loaded into mg, it is often referred to as a buffer.
	+
	+The mg editor is capable of editing multiple buffers at the same time. When you
	+open a second file with C-x C-f, the first buffer is still being edited by mg.
	+
	+Both buffers can be viewed simultaneously because mg can support several windows
	+at the same time, each one displaying different text. To split a screen into two
	+horizontal windows use C-x 2. To return to one window, use C-x 1 to close the
	+other windows and only keep the current window.
	+
	+>> Use C-x 2 to split the screen into two windows.
	+
	+>> Use C-x o to move from one window to the other. You can scroll up and down
	+ in each window using the cursor keys or C-n and C-p keys.
	+
	+>> Use C-x 1 to restore back to one window.
	+
	+You can list all the buffers that are opened by mg by typing C-x C-b. The
	+screen should divide into two and the top window will list the buffers that
	+are currently open. Use C-x o to switch to the top window, then use the arrow
	+keys to move to the buffer you wish to switch to, and then type the Enter key to
	+select that buffer. Then use C-x 1 to switch back to only one window.
	+
	+You may also move back to the last opened buffer by using C-x b to toggle back
	+and forth between two buffers. Note the difference between C-x b and C-x C-b.
	+
	+>> Use C-x C-f to open a new file
	+>> Use C-x b to switch back and forth between that buffer and this one.
	+
	+To kill any buffer, use C-x k. You will be prompted for the buffer to kill.
	+By default, the current buffer is selected as the one to kill. You may also
	+type another buffer name or use C-g to cancel the operation.
	+
	+Extended Commands
	+-----------------
	+
	+The mg editor has several extended commands, more than what can be covered
	+by the Control and Meta keys. The mg editor gets around this by using what is
	+called the X (eXtend) command. There are two forms of this:
	+
	+ C-x Character eXtension. Followed by one character.
	+ M-x Named character eXtension. Followed by a long command.
	+
	+You've already seen C-x C-f and C-x C-s to open and save a file. There are
	+other longer commands. For instance, you can also open a file by typing
	+M-x find-file Enter. When you type a command using M-x, mg prompts you for
	+the command at the bottom of the screen. You can type out the whole command
	+if you wish, or you can type out part of the command and then use the TAB key
	+for autocompleting the command.
	+
	+For instance, to replace text, you can type M-x repl TAB enter to execute
	+the replace-text command. To cancel this command, type C-g.
	+
	+To see a list of all available mg(1) commands, consult the man page.
	+
	+Exiting mg
	+----------
	+
	+To exit mg temporarily and return to the shell, use C-z. This will take you
	+back to the command shell. To return back to mg, type fg in the shell and you
	+will be returned to your mg session.
	+
	+To exit mg permanently, type C-x C-c. If you have any unsaved buffers, you
	+will be asked if you wish to save them or not.
	+
	+Conclusion
	+----------
	+
	+This tutorial is meant to get new users up and running with mg. There is more
	+information available via the mg(1) man page. If you have any suggestions for
	+improvement, please don't hesitate to drop a message or (better still) submit
	+a diff to tech@openbsd.org.
	+
	+Author Info
	+-----------
	+
	+Original Author of this document: Mayukh Bose,
	+Date last updated: 2018-05-27
	+
	+Copyright
	+---------
	+
	+None. This document is in the public domain.
	Index: contrib/mg/undo.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/undo.c
	@@ -0,0 +1,602 @@
	+/* $OpenBSD: undo.c,v 1.58 2016/09/05 08:10:58 lum Exp $ */
	+/*
	+ * This file is in the public domain
	+ */
	+
	+#include <sys/queue.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+
	+#include "def.h"
	+#include "kbd.h"
	+
	+#define MAX_FREE_RECORDS 32
	+
	+/*
	+ * Local variables
	+ */
	+static struct undoq undo_free;
	+static int undo_free_num;
	+static int boundary_flag = TRUE;
	+static int undo_enable_flag = TRUE;
	+
	+/*
	+ * Local functions
	+ */
	+static int find_dot(struct line *, int);
	+static int find_lo(int, struct line *, int , int *);
	+static struct undo_rec *new_undo_record(void);
	+static int drop_oldest_undo_record(void);
	+
	+/*
	+ * find_dot, find_lo()
	+ *
	+ * Find an absolute dot in the buffer from a line/offset pair, and vice-versa.
	+ *
	+ * Since lines can be deleted while they are referenced by undo record, we
	+ * need to have an absolute dot to have something reliable.
	+ */
	+static int
	+find_dot(struct line *lp, int off)
	+{
	+ int count = 0;
	+ struct line *p;
	+
	+ for (p = curbp->b_headp; p != lp; p = lforw(p)) {
	+ if (count != 0) {
	+ if (p == curbp->b_headp) {
	+ dobeep();
	+ ewprintf("Error: Undo stuff called with a"
	+ "nonexistent line");
	+ return (FALSE);
	+ }
	+ }
	+ count += llength(p) + 1;
	+ }
	+ count += off;
	+
	+ return (count);
	+}
	+
	+static int
	+find_lo(int pos, struct line *olp, int offset, int *lnum)
	+{
	+ struct line *p;
	+ int lineno;
	+
	+ p = curbp->b_headp;
	+ lineno = 0;
	+ while (pos > llength(p)) {
	+ pos -= llength(p) + 1;
	+ if ((p = lforw(p)) == curbp->b_headp) {
	+ *olp = NULL;
	+ *offset = 0;
	+ return (FALSE);
	+ }
	+ lineno++;
	+ }
	+ *olp = p;
	+ *offset = pos;
	+ *lnum = lineno;
	+
	+ return (TRUE);
	+}
	+
	+static struct undo_rec *
	+new_undo_record(void)
	+{
	+ struct undo_rec *rec;
	+
	+ rec = TAILQ_FIRST(&undo_free);
	+ if (rec != NULL) {
	+ /* Remove it from the free-list */
	+ TAILQ_REMOVE(&undo_free, rec, next);
	+ undo_free_num--;
	+ } else {
	+ if ((rec = malloc(sizeof(*rec))) == NULL)
	+ panic("Out of memory in undo code (record)");
	+ }
	+ memset(rec, 0, sizeof(struct undo_rec));
	+
	+ return (rec);
	+}
	+
	+void
	+free_undo_record(struct undo_rec *rec)
	+{
	+ static int initialised = 0;
	+
	+ /*
	+ * On the first run, do initialisation of the free list.
	+ */
	+ if (initialised == 0) {
	+ TAILQ_INIT(&undo_free);
	+ initialised = 1;
	+ }
	+ free(rec->content);
	+ rec->content = NULL;
	+ if (undo_free_num >= MAX_FREE_RECORDS) {
	+ free(rec);
	+ return;
	+ }
	+ undo_free_num++;
	+
	+ TAILQ_INSERT_HEAD(&undo_free, rec, next);
	+}
	+
	+/*
	+ * Drop the oldest undo record in our list. Return 1 if we could remove it,
	+ * 0 if the undo list was empty.
	+ */
	+static int
	+drop_oldest_undo_record(void)
	+{
	+ struct undo_rec *rec;
	+
	+ rec = TAILQ_LAST(&curbp->b_undo, undoq);
	+ if (rec != NULL) {
	+ undo_free_num--;
	+ TAILQ_REMOVE(&curbp->b_undo, rec, next);
	+ free_undo_record(rec);
	+ return (1);
	+ }
	+ return (0);
	+}
	+
	+static int
	+lastrectype(void)
	+{
	+ struct undo_rec *rec;
	+
	+ if ((rec = TAILQ_FIRST(&curbp->b_undo)) != NULL)
	+ return (rec->type);
	+ return (0);
	+}
	+
	+/*
	+ * Returns TRUE if undo is enabled, FALSE otherwise.
	+ */
	+int
	+undo_enabled(void)
	+{
	+ return (undo_enable_flag);
	+}
	+
	+/*
	+ * undo_enable: toggle undo_enable.
	+ * Returns the previous value of the flag.
	+ */
	+int
	+undo_enable(int f, int n)
	+{
	+ int pon = undo_enable_flag;
	+
	+ if (f & (FFARG \| FFRAND))
	+ undo_enable_flag = n > 0;
	+ else
	+ undo_enable_flag = !undo_enable_flag;
	+
	+ if (!(f & FFRAND))
	+ ewprintf("Undo %sabled", undo_enable_flag ? "en" : "dis");
	+
	+ return (pon);
	+}
	+
	+/*
	+ * If undo is enabled, then:
	+ * Toggle undo boundary recording.
	+ * If called with an argument, (n > 0) => enable. Otherwise disable.
	+ * In either case, add an undo boundary
	+ * If undo is disabled, this function has no effect.
	+ */
	+int
	+undo_boundary_enable(int f, int n)
	+{
	+ int bon = boundary_flag;
	+
	+ if (!undo_enable_flag)
	+ return (FALSE);
	+
	+ undo_add_boundary(FFRAND, 1);
	+
	+ if (f & (FFARG \| FFRAND))
	+ boundary_flag = n > 0;
	+ else
	+ boundary_flag = !boundary_flag;
	+
	+ if (!(f & FFRAND))
	+ ewprintf("Undo boundaries %sabled",
	+ boundary_flag ? "en" : "dis");
	+
	+ return (bon);
	+}
	+
	+/*
	+ * Record an undo boundary, unless boundary_flag == FALSE.
	+ * Does nothing if previous undo entry is already a boundary or 'modified' flag.
	+ */
	+int
	+undo_add_boundary(int f, int n)
	+{
	+ struct undo_rec *rec;
	+ int last;
	+
	+ if (boundary_flag == FALSE)
	+ return (FALSE);
	+
	+ last = lastrectype();
	+ if (last == BOUNDARY \|\| last == MODIFIED)
	+ return (TRUE);
	+
	+ rec = new_undo_record();
	+ rec->type = BOUNDARY;
	+
	+ TAILQ_INSERT_HEAD(&curbp->b_undo, rec, next);
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * Record an undo "modified" boundary
	+ */
	+void
	+undo_add_modified(void)
	+{
	+ struct undo_rec rec, trec;
	+
	+ TAILQ_FOREACH_SAFE(rec, &curbp->b_undo, next, trec)
	+ if (rec->type == MODIFIED) {
	+ TAILQ_REMOVE(&curbp->b_undo, rec, next);
	+ free_undo_record(rec);
	+ }
	+
	+ rec = new_undo_record();
	+ rec->type = MODIFIED;
	+
	+ TAILQ_INSERT_HEAD(&curbp->b_undo, rec, next);
	+
	+ return;
	+}
	+
	+int
	+undo_add_insert(struct line *lp, int offset, int size)
	+{
	+ struct region reg;
	+ struct undo_rec *rec;
	+ int pos;
	+
	+ if (!undo_enable_flag)
	+ return (TRUE);
	+
	+ memset(&reg, 0, sizeof(reg));
	+ reg.r_linep = lp;
	+ reg.r_offset = offset;
	+ reg.r_size = size;
	+
	+ pos = find_dot(lp, offset);
	+
	+ /*
	+ * We try to reuse the last undo record to `compress' things.
	+ */
	+ rec = TAILQ_FIRST(&curbp->b_undo);
	+ if (rec != NULL && rec->type == INSERT) {
	+ if (rec->pos + rec->region.r_size == pos) {
	+ rec->region.r_size += reg.r_size;
	+ return (TRUE);
	+ }
	+ }
	+
	+ /*
	+ * We couldn't reuse the last undo record, so prepare a new one.
	+ */
	+ rec = new_undo_record();
	+ rec->pos = pos;
	+ rec->type = INSERT;
	+ memmove(&rec->region, &reg, sizeof(struct region));
	+ rec->content = NULL;
	+
	+ undo_add_boundary(FFRAND, 1);
	+
	+ TAILQ_INSERT_HEAD(&curbp->b_undo, rec, next);
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * This of course must be done _before_ the actual deletion is done.
	+ */
	+int
	+undo_add_delete(struct line *lp, int offset, int size, int isreg)
	+{
	+ struct region reg;
	+ struct undo_rec *rec;
	+ int pos;
	+
	+ if (!undo_enable_flag)
	+ return (TRUE);
	+
	+ memset(&reg, 0, sizeof(reg));
	+ reg.r_linep = lp;
	+ reg.r_offset = offset;
	+ reg.r_size = size;
	+
	+ pos = find_dot(lp, offset);
	+
	+ if (offset == llength(lp)) /* if it's a newline... */
	+ undo_add_boundary(FFRAND, 1);
	+ else if ((rec = TAILQ_FIRST(&curbp->b_undo)) != NULL) {
	+ /*
	+ * Separate this command from the previous one if we're not
	+ * just before the previous record...
	+ */
	+ if (!isreg && rec->type == DELETE) {
	+ if (rec->pos - rec->region.r_size != pos)
	+ undo_add_boundary(FFRAND, 1);
	+ }
	+ }
	+ rec = new_undo_record();
	+ rec->pos = pos;
	+ if (isreg)
	+ rec->type = DELREG;
	+ else
	+ rec->type = DELETE;
	+ memmove(&rec->region, &reg, sizeof(struct region));
	+ do {
	+ rec->content = malloc(reg.r_size + 1);
	+ } while ((rec->content == NULL) && drop_oldest_undo_record());
	+
	+ if (rec->content == NULL)
	+ panic("Out of memory");
	+
	+ region_get_data(&reg, rec->content, reg.r_size);
	+
	+ if (isreg \|\| lastrectype() != DELETE)
	+ undo_add_boundary(FFRAND, 1);
	+
	+ TAILQ_INSERT_HEAD(&curbp->b_undo, rec, next);
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * This of course must be called before the change takes place.
	+ */
	+int
	+undo_add_change(struct line *lp, int offset, int size)
	+{
	+ if (!undo_enable_flag)
	+ return (TRUE);
	+ undo_add_boundary(FFRAND, 1);
	+ boundary_flag = FALSE;
	+ undo_add_delete(lp, offset, size, 0);
	+ undo_add_insert(lp, offset, size);
	+ boundary_flag = TRUE;
	+ undo_add_boundary(FFRAND, 1);
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * Show the undo records for the current buffer in a new buffer.
	+ */
	+/* ARGSUSED */
	+int
	+undo_dump(int f, int n)
	+{
	+ struct undo_rec *rec;
	+ struct buffer *bp;
	+ struct mgwin *wp;
	+ char buf[4096], tmp[1024];
	+ int num;
	+
	+ /*
	+ * Prepare the buffer for insertion.
	+ */
	+ if ((bp = bfind("undo", TRUE)) == NULL)
	+ return (FALSE);
	+ bp->b_flag \|= BFREADONLY;
	+ bclear(bp);
	+ if ((wp = popbuf(bp, WNONE)) == NULL)
	+ return (FALSE);
	+
	+ for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
	+ if (wp->w_bufp == bp) {
	+ wp->w_dotp = bp->b_headp;
	+ wp->w_doto = 0;
	+ }
	+ }
	+
	+ num = 0;
	+ TAILQ_FOREACH(rec, &curbp->b_undo, next) {
	+ num++;
	+ snprintf(buf, sizeof(buf),
	+ "%d:\t %s at %d ", num,
	+ (rec->type == DELETE) ? "DELETE":
	+ (rec->type == DELREG) ? "DELREGION":
	+ (rec->type == INSERT) ? "INSERT":
	+ (rec->type == BOUNDARY) ? "----" :
	+ (rec->type == MODIFIED) ? "MODIFIED": "UNKNOWN",
	+ rec->pos);
	+
	+ if (rec->content) {
	+ (void)strlcat(buf, "\"", sizeof(buf));
	+ snprintf(tmp, sizeof(tmp), "%.*s", rec->region.r_size,
	+ rec->content);
	+ (void)strlcat(buf, tmp, sizeof(buf));
	+ (void)strlcat(buf, "\"", sizeof(buf));
	+ }
	+ snprintf(tmp, sizeof(tmp), " [%d]", rec->region.r_size);
	+ if (strlcat(buf, tmp, sizeof(buf)) >= sizeof(buf)) {
	+ dobeep();
	+ ewprintf("Undo record too large. Aborted.");
	+ return (FALSE);
	+ }
	+ addlinef(bp, "%s", buf);
	+ }
	+ for (wp = wheadp; wp != NULL; wp = wp->w_wndp) {
	+ if (wp->w_bufp == bp) {
	+ wp->w_dotline = num+1;
	+ wp->w_rflag \|= WFFULL;
	+ }
	+ }
	+ return (TRUE);
	+}
	+
	+/*
	+ * After the user did action1, then action2, then action3:
	+ *
	+ * [action3] <--- Undoptr
	+ * [action2]
	+ * [action1]
	+ * ------
	+ * [undo]
	+ *
	+ * After undo:
	+ *
	+ * [undo of action3]
	+ * [action2] <--- Undoptr
	+ * [action1]
	+ * ------
	+ * [undo]
	+ *
	+ * After another undo:
	+ *
	+ *
	+ * [undo of action2]
	+ * [undo of action3]
	+ * [action1] <--- Undoptr
	+ * ------
	+ * [undo]
	+ *
	+ * Note that the "undo of actionX" have no special meaning. Only when
	+ * we undo a deletion, the insertion will be recorded just as if it
	+ * was typed on the keyboard. Resulting in the inverse operation being
	+ * saved in the list.
	+ *
	+ * If undoptr reaches the bottom of the list, or if we moved between
	+ * two undo actions, we make it point back at the topmost record. This is
	+ * how we handle redoing.
	+ */
	+/* ARGSUSED */
	+int
	+undo(int f, int n)
	+{
	+ struct undo_rec ptr, nptr;
	+ int done, rval;
	+ struct line *lp;
	+ int offset, save;
	+ static int nulled = FALSE;
	+ int lineno;
	+
	+ if (n < 0)
	+ return (FALSE);
	+
	+ ptr = curbp->b_undoptr;
	+
	+ /* first invocation, make ptr point back to the top of the list */
	+ if ((ptr == NULL && nulled == TRUE) \|\| rptcount == 0) {
	+ ptr = TAILQ_FIRST(&curbp->b_undo);
	+ nulled = TRUE;
	+ }
	+
	+ rval = TRUE;
	+ while (n--) {
	+ /* if we have a spurious boundary, free it and move on.... */
	+ while (ptr && ptr->type == BOUNDARY) {
	+ nptr = TAILQ_NEXT(ptr, next);
	+ TAILQ_REMOVE(&curbp->b_undo, ptr, next);
	+ free_undo_record(ptr);
	+ ptr = nptr;
	+ }
	+ /*
	+ * Ptr is NULL, but on the next run, it will point to the
	+ * top again, redoing all stuff done in the buffer since
	+ * its creation.
	+ */
	+ if (ptr == NULL) {
	+ dobeep();
	+ ewprintf("No further undo information");
	+ rval = FALSE;
	+ nulled = TRUE;
	+ break;
	+ }
	+ nulled = FALSE;
	+
	+ /*
	+ * Loop while we don't get a boundary specifying we've
	+ * finished the current action...
	+ */
	+
	+ undo_add_boundary(FFRAND, 1);
	+
	+ save = boundary_flag;
	+ boundary_flag = FALSE;
	+
	+ done = 0;
	+ do {
	+ /*
	+ * Move to where this has to apply
	+ *
	+ * Boundaries (and the modified flag) are put as
	+ * position 0 (to save lookup time in find_dot)
	+ * so we must not move there...
	+ */
	+ if (ptr->type != BOUNDARY && ptr->type != MODIFIED) {
	+ if (find_lo(ptr->pos, &lp,
	+ &offset, &lineno) == FALSE) {
	+ dobeep();
	+ ewprintf("Internal error in Undo!");
	+ rval = FALSE;
	+ break;
	+ }
	+ curwp->w_dotp = lp;
	+ curwp->w_doto = offset;
	+ curwp->w_markline = curwp->w_dotline;
	+ curwp->w_dotline = lineno;
	+ }
	+
	+ /*
	+ * Do operation^-1
	+ */
	+ switch (ptr->type) {
	+ case INSERT:
	+ ldelete(ptr->region.r_size, KNONE);
	+ break;
	+ case DELETE:
	+ lp = curwp->w_dotp;
	+ offset = curwp->w_doto;
	+ region_put_data(ptr->content,
	+ ptr->region.r_size);
	+ curwp->w_dotp = lp;
	+ curwp->w_doto = offset;
	+ break;
	+ case DELREG:
	+ region_put_data(ptr->content,
	+ ptr->region.r_size);
	+ break;
	+ case BOUNDARY:
	+ done = 1;
	+ break;
	+ case MODIFIED:
	+ curbp->b_flag &= ~BFCHG;
	+ break;
	+ default:
	+ break;
	+ }
	+
	+ /* And move to next record */
	+ ptr = TAILQ_NEXT(ptr, next);
	+ } while (ptr != NULL && !done);
	+
	+ boundary_flag = save;
	+ undo_add_boundary(FFRAND, 1);
	+
	+ ewprintf("Undo!");
	+ }
	+
	+ curbp->b_undoptr = ptr;
	+
	+ return (rval);
	+}
	Index: contrib/mg/util.h
	===================================================================
	--- /dev/null
	+++ contrib/mg/util.h
	@@ -0,0 +1,121 @@
	+/* $OpenBSD: util.h,v 1.34 2013/06/03 21:07:02 tedu Exp $ */
	+/* $NetBSD: util.h,v 1.2 1996/05/16 07:00:22 thorpej Exp $ */
	+
	+/*-
	+ * Copyright (c) 1995
	+ * The Regents of the University of California. All rights reserved.
	+ * Portions Copyright (c) 1996, Jason Downs. All rights reserved.
	+ *
	+ * Redistribution and use in source and binary forms, with or without
	+ * modification, are permitted provided that the following conditions
	+ * are met:
	+ * 1. Redistributions of source code must retain the above copyright
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ * 3. Neither the name of the University nor the names of its contributors
	+ * may be used to endorse or promote products derived from this software
	+ * without specific prior written permission.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	+ * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	+ * SUCH DAMAGE.
	+ */
	+
	+#ifndef _UTIL_H_
	+#define _UTIL_H_
	+
	+#include <sys/types.h>
	+#include <stdint.h>
	+
	+/*
	+ * fparseln() specific operation flags.
	+ */
	+#define FPARSELN_UNESCESC 0x01
	+#define FPARSELN_UNESCCONT 0x02
	+#define FPARSELN_UNESCCOMM 0x04
	+#define FPARSELN_UNESCREST 0x08
	+#define FPARSELN_UNESCALL 0x0f
	+
	+/*
	+ * opendev() specific operation flags.
	+ */
	+#define OPENDEV_PART 0x01 /* Try to open the raw partition. */
	+#define OPENDEV_BLCK 0x04 /* Open block, not character device. */
	+
	+/*
	+ * uucplock(3) specific flags.
	+ */
	+#define UU_LOCK_INUSE (1)
	+#define UU_LOCK_OK (0)
	+#define UU_LOCK_OPEN_ERR (-1)
	+#define UU_LOCK_READ_ERR (-2)
	+#define UU_LOCK_CREAT_ERR (-3)
	+#define UU_LOCK_WRITE_ERR (-4)
	+#define UU_LOCK_LINK_ERR (-5)
	+#define UU_LOCK_TRY_ERR (-6)
	+#define UU_LOCK_OWNER_ERR (-7)
	+
	+/*
	+ * fmt_scaled(3) specific flags.
	+ */
	+#define FMT_SCALED_STRSIZE 7 /* minus sign, 4 digits, suffix, null byte */
	+
	+/*
	+ * stub struct definitions.
	+ */
	+struct __sFILE;
	+struct login_cap;
	+struct passwd;
	+struct termios;
	+struct utmp;
	+struct winsize;
	+
	+char fparseln(FILE , size_t , size_t , const char[3], int);
	+void login(struct utmp *);
	+int login_tty(int);
	+int logout(const char *);
	+void logwtmp(const char , const char , const char *);
	+int opendev(const char , int, int, char *);
	+int pidfile(const char *);
	+void pw_setdir(const char *);
	+char pw_file(const char );
	+int pw_lock(int);
	+int pw_mkdb(char *, int);
	+int pw_abort(void);
	+void pw_init(void);
	+void pw_edit(int, const char *);
	+void pw_prompt(void);
	+void pw_copy(int, int, const struct passwd , const struct passwd );
	+int pw_scan(char , struct passwd , int *);
	+void pw_error(const char *, int, int);
	+int openpty(int , int , char , struct termios , struct winsize *);
	+int opendisk(const char , int, char , size_t, int);
	+pid_t forkpty(int , char , struct termios , struct winsize );
	+int getmaxpartitions(void);
	+int getrawpartition(void);
	+void login_fbtab(const char *, uid_t, gid_t);
	+int login_check_expire(struct __sFILE , struct passwd , char *, int);
	+char readlabelfs(char , int);
	+const char *uu_lockerr(int);
	+int uu_lock(const char *);
	+int uu_lock_txfr(const char *, pid_t);
	+int uu_unlock(const char *);
	+int fmt_scaled(long long, char *);
	+int scan_scaled(char , long long );
	+int isduid(const char *, int);
	+int pkcs5_pbkdf2(const char , size_t, const uint8_t , size_t,
	+ uint8_t *, size_t, unsigned int);
	+int bcrypt_pbkdf(const char , size_t, const uint8_t , size_t,
	+ uint8_t *, size_t, unsigned int);
	+
	+#endif /* !_UTIL_H_ */
	Index: contrib/mg/util.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/util.c
	@@ -0,0 +1,529 @@
	+/* $OpenBSD: util.c,v 1.43 2021/03/01 10:51:14 lum Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * Assorted commands.
	+ * This file contains the command processors for a large assortment of
	+ * unrelated commands. The only thing they have in common is that they
	+ * are all command processors.
	+ */
	+
	+#include <sys/queue.h>
	+#include <ctype.h>
	+#include <signal.h>
	+#include <stdio.h>
	+
	+#include "def.h"
	+
	+/*
	+ * Display a bunch of useful information about the current location of dot.
	+ * The character under the cursor (in octal), the current line, row, and
	+ * column, and approximate position of the cursor in the file (as a
	+ * percentage) is displayed.
	+ * Also included at the moment are some values in parenthesis for debugging
	+ * explicit newline inclusion into the buffer.
	+ * The column position assumes an infinite
	+ * position display; it does not truncate just because the screen does.
	+ * This is normally bound to "C-x =".
	+ */
	+/* ARGSUSED */
	+int
	+showcpos(int f, int n)
	+{
	+ struct line *clp;
	+ char *msg;
	+ long nchar, cchar;
	+ int nline, row;
	+ int cline, cbyte; /* Current line/char/byte */
	+ int ratio;
	+
	+ /* collect the data */
	+ clp = bfirstlp(curbp);
	+ msg = "Char:";
	+ cchar = 0;
	+ cline = 0;
	+ cbyte = 0;
	+ nchar = 0;
	+ nline = 0;
	+ for (;;) {
	+ /* count lines and display total as (raw) 'lines' and
	+ compare with b_lines */
	+ ++nline;
	+ if (clp == curwp->w_dotp) {
	+ /* obtain (raw) dot line # and compare with w_dotline */
	+ cline = nline;
	+ cchar = nchar + curwp->w_doto;
	+ if (curwp->w_doto == llength(clp))
	+ /* fake a \n at end of line */
	+ cbyte = *curbp->b_nlchr;
	+ else
	+ cbyte = lgetc(clp, curwp->w_doto);
	+ }
	+ /* include # of chars in this line for point-thru-buff ratio */
	+ nchar += llength(clp);
	+ clp = lforw(clp);
	+ if (clp == curbp->b_headp) {
	+ if (cbyte == *curbp->b_nlchr &&
	+ cline == curbp->b_lines) {
	+ /* swap faked \n for EOB msg */
	+ cbyte = EOF;
	+ msg = "(EOB)";
	+ }
	+ break;
	+ }
	+ /* count the implied newline */
	+ nchar++;
	+ }
	+ /* determine row # within current window */
	+ row = curwp->w_toprow + 1;
	+ clp = curwp->w_linep;
	+ while (clp != curbp->b_headp && clp != curwp->w_dotp) {
	+ ++row;
	+ clp = lforw(clp);
	+ }
	+ ratio = nchar ? (100L * cchar) / nchar : 100;
	+ ewprintf("%s %c (0%o) point=%ld(%d%%) line=%d row=%d col=%d" \
	+ " (blines=%d rlines=%d l_size=%d)", msg,
	+ cbyte, cbyte, cchar, ratio, cline, row, getcolpos(curwp),
	+ curbp->b_lines, nline, clp->l_size);
	+ return (TRUE);
	+}
	+
	+int
	+getcolpos(struct mgwin *wp)
	+{
	+ int col, i, c;
	+ char tmp[5];
	+
	+ /* determine column */
	+ col = 0;
	+
	+ for (i = 0; i < wp->w_doto; ++i) {
	+ c = lgetc(wp->w_dotp, i);
	+ if (c == '\t'
	+#ifdef NOTAB
	+ && !(wp->w_bufp->b_flag & BFNOTAB)
	+#endif /* NOTAB */
	+ ) {
	+ col \|= 0x07;
	+ col++;
	+ } else if (ISCTRL(c) != FALSE)
	+ col += 2;
	+ else if (isprint(c)) {
	+ col++;
	+ } else {
	+ col += snprintf(tmp, sizeof(tmp), "\\%o", c);
	+ }
	+
	+ }
	+ return (col);
	+}
	+
	+/*
	+ * Twiddle the two characters in front of and under dot, then move forward
	+ * one character. Treat new-line characters the same as any other.
	+ * Normally bound to "C-t". This always works within a line, so "WFEDIT"
	+ * is good enough.
	+ */
	+/* ARGSUSED */
	+int
	+twiddle(int f, int n)
	+{
	+ struct line *dotp;
	+ int doto, cr;
	+
	+ if (n == 0)
	+ return (TRUE);
	+
	+ dotp = curwp->w_dotp;
	+ doto = curwp->w_doto;
	+
	+ /* Don't twiddle if the dot is on the first char of buffer */
	+ if (doto == 0 && lback(dotp) == curbp->b_headp) {
	+ dobeep();
	+ ewprintf("Beginning of buffer");
	+ return(FALSE);
	+ }
	+ /* Don't twiddle if the dot is on the last char of buffer */
	+ if (doto == llength(dotp) && lforw(dotp) == curbp->b_headp) {
	+ dobeep();
	+ return(FALSE);
	+ }
	+ undo_boundary_enable(FFRAND, 0);
	+ if (doto == 0 && doto == llength(dotp)) { /* only '\n' on this line */
	+ (void)forwline(FFRAND, 1);
	+ curwp->w_doto = 0;
	+ } else {
	+ if (doto == 0) { /* 1st twiddle is on 1st character of a line */
	+ cr = lgetc(dotp, doto);
	+ (void)backdel(FFRAND, 1);
	+ (void)forwchar(FFRAND, 1);
	+ lnewline();
	+ linsert(1, cr);
	+ (void)backdel(FFRAND, 1);
	+ } else { /* twiddle is elsewhere in line */
	+ cr = lgetc(dotp, doto - 1);
	+ (void)backdel(FFRAND, 1);
	+ (void)forwchar(FFRAND, 1);
	+ linsert(1, cr);
	+ }
	+ }
	+ undo_boundary_enable(FFRAND, 1);
	+ lchange(WFEDIT);
	+ return (TRUE);
	+}
	+
	+/*
	+ * Open up some blank space. The basic plan is to insert a bunch of
	+ * newlines, and then back up over them. Everything is done by the
	+ * subcommand processors. They even handle the looping. Normally this
	+ * is bound to "C-o".
	+ */
	+/* ARGSUSED */
	+int
	+openline(int f, int n)
	+{
	+ int i, s;
	+
	+ if (n < 0)
	+ return (FALSE);
	+ if (n == 0)
	+ return (TRUE);
	+
	+ /* insert newlines */
	+ undo_boundary_enable(FFRAND, 0);
	+ i = n;
	+ do {
	+ s = lnewline();
	+ } while (s == TRUE && --i);
	+
	+ /* then go back up overtop of them all */
	+ if (s == TRUE)
	+ s = backchar(f \| FFRAND, n);
	+ undo_boundary_enable(FFRAND, 1);
	+ return (s);
	+}
	+
	+/*
	+ * Insert a newline.
	+ */
	+/* ARGSUSED */
	+int
	+enewline(int f, int n)
	+{
	+ int s;
	+
	+ if (n < 0)
	+ return (FALSE);
	+
	+ while (n--) {
	+ if ((s = lnewline()) != TRUE)
	+ return (s);
	+ }
	+ return (TRUE);
	+}
	+
	+/*
	+ * Delete blank lines around dot. What this command does depends if dot is
	+ * sitting on a blank line. If dot is sitting on a blank line, this command
	+ * deletes all the blank lines above and below the current line. If it is
	+ * sitting on a non blank line then it deletes all of the blank lines after
	+ * the line. Normally this command is bound to "C-x C-o". Any argument is
	+ * ignored.
	+ */
	+/* ARGSUSED */
	+int
	+deblank(int f, int n)
	+{
	+ struct line lp1, lp2;
	+ RSIZE nld;
	+
	+ lp1 = curwp->w_dotp;
	+ while (llength(lp1) == 0 && (lp2 = lback(lp1)) != curbp->b_headp)
	+ lp1 = lp2;
	+ lp2 = lp1;
	+ nld = (RSIZE)0;
	+ while ((lp2 = lforw(lp2)) != curbp->b_headp && llength(lp2) == 0)
	+ ++nld;
	+ if (nld == 0)
	+ return (TRUE);
	+ curwp->w_dotp = lforw(lp1);
	+ curwp->w_doto = 0;
	+ return (ldelete((RSIZE)nld, KNONE));
	+}
	+
	+/*
	+ * Delete any whitespace around dot, then insert a space.
	+ */
	+int
	+justone(int f, int n)
	+{
	+ undo_boundary_enable(FFRAND, 0);
	+ (void)delwhite(f, n);
	+ linsert(1, ' ');
	+ undo_boundary_enable(FFRAND, 1);
	+ return (TRUE);
	+}
	+
	+/*
	+ * Delete any whitespace around dot.
	+ */
	+/* ARGSUSED */
	+int
	+delwhite(int f, int n)
	+{
	+ int col, s;
	+
	+ col = curwp->w_doto;
	+
	+ while (col < llength(curwp->w_dotp) &&
	+ (isspace(lgetc(curwp->w_dotp, col))))
	+ ++col;
	+ do {
	+ if (curwp->w_doto == 0) {
	+ s = FALSE;
	+ break;
	+ }
	+ if ((s = backchar(FFRAND, 1)) != TRUE)
	+ break;
	+ } while (isspace(lgetc(curwp->w_dotp, curwp->w_doto)));
	+
	+ if (s == TRUE)
	+ (void)forwchar(FFRAND, 1);
	+ (void)ldelete((RSIZE)(col - curwp->w_doto), KNONE);
	+ return (TRUE);
	+}
	+
	+/*
	+ * Delete any leading whitespace on the current line
	+ */
	+int
	+delleadwhite(int f, int n)
	+{
	+ int soff, ls;
	+ struct line *slp;
	+
	+ /* Save current position */
	+ slp = curwp->w_dotp;
	+ soff = curwp->w_doto;
	+
	+ for (ls = 0; ls < llength(slp); ls++)
	+ if (!isspace(lgetc(slp, ls)))
	+ break;
	+ gotobol(FFRAND, 1);
	+ forwdel(FFRAND, ls);
	+ soff -= ls;
	+ if (soff < 0)
	+ soff = 0;
	+ forwchar(FFRAND, soff);
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * Delete any trailing whitespace on the current line
	+ */
	+int
	+deltrailwhite(int f, int n)
	+{
	+ int soff;
	+
	+ /* Save current position */
	+ soff = curwp->w_doto;
	+
	+ gotoeol(FFRAND, 1);
	+ delwhite(FFRAND, 1);
	+
	+ /* restore original position, if possible */
	+ if (soff < curwp->w_doto)
	+ curwp->w_doto = soff;
	+
	+ return (TRUE);
	+}
	+
	+
	+
	+/*
	+ * Insert a newline, then enough tabs and spaces to duplicate the indentation
	+ * of the previous line. Assumes tabs are every eight characters. Quite
	+ * simple. Figure out the indentation of the current line. Insert a newline
	+ * by calling the standard routine. Insert the indentation by inserting the
	+ * right number of tabs and spaces. Return TRUE if all ok. Return FALSE if
	+ * one of the subcommands failed. Normally bound to "C-m".
	+ */
	+/* ARGSUSED */
	+int
	+lfindent(int f, int n)
	+{
	+ int c, i, nicol;
	+ int s = TRUE;
	+
	+ if (n < 0)
	+ return (FALSE);
	+
	+ undo_boundary_enable(FFRAND, 0);
	+ while (n--) {
	+ nicol = 0;
	+ for (i = 0; i < llength(curwp->w_dotp); ++i) {
	+ c = lgetc(curwp->w_dotp, i);
	+ if (c != ' ' && c != '\t')
	+ break;
	+ if (c == '\t')
	+ nicol \|= 0x07;
	+ ++nicol;
	+ }
	+ if (lnewline() == FALSE \|\| ((
	+#ifdef NOTAB
	+ curbp->b_flag & BFNOTAB) ? linsert(nicol, ' ') == FALSE : (
	+#endif /* NOTAB */
	+ ((i = nicol / 8) != 0 && linsert(i, '\t') == FALSE) \|\|
	+ ((i = nicol % 8) != 0 && linsert(i, ' ') == FALSE)))) {
	+ s = FALSE;
	+ break;
	+ }
	+ }
	+ undo_boundary_enable(FFRAND, 1);
	+ return (s);
	+}
	+
	+/*
	+ * Indent the current line. Delete existing leading whitespace,
	+ * and use tabs/spaces to achieve correct indentation. Try
	+ * to leave dot where it started.
	+ */
	+int
	+indent(int f, int n)
	+{
	+ int soff, i;
	+
	+ if (n < 0)
	+ return (FALSE);
	+
	+ delleadwhite(FFRAND, 1);
	+
	+ /* If not invoked with a numerical argument, done */
	+ if (!(f & FFARG))
	+ return (TRUE);
	+
	+ /* insert appropriate whitespace */
	+ soff = curwp->w_doto;
	+ (void)gotobol(FFRAND, 1);
	+ if (
	+#ifdef NOTAB
	+ (curbp->b_flag & BFNOTAB) ? linsert(n, ' ') == FALSE :
	+#endif /* NOTAB */
	+ (((i = n / 8) != 0 && linsert(i, '\t') == FALSE) \|\|
	+ ((i = n % 8) != 0 && linsert(i, ' ') == FALSE)))
	+ return (FALSE);
	+
	+ forwchar(FFRAND, soff);
	+
	+ return (TRUE);
	+}
	+
	+
	+/*
	+ * Delete forward. This is real easy, because the basic delete routine does
	+ * all of the work. Watches for negative arguments, and does the right thing.
	+ * If any argument is present, it kills rather than deletes, to prevent loss
	+ * of text if typed with a big argument. Normally bound to "C-d".
	+ */
	+/* ARGSUSED */
	+int
	+forwdel(int f, int n)
	+{
	+ if (n < 0)
	+ return (backdel(f \| FFRAND, -n));
	+
	+ /* really a kill */
	+ if (f & FFARG) {
	+ if ((lastflag & CFKILL) == 0)
	+ kdelete();
	+ thisflag \|= CFKILL;
	+ }
	+
	+ return (ldelete((RSIZE) n, (f & FFARG) ? KFORW : KNONE));
	+}
	+
	+/*
	+ * Delete backwards. This is quite easy too, because it's all done with
	+ * other functions. Just move the cursor back, and delete forwards. Like
	+ * delete forward, this actually does a kill if presented with an argument.
	+ */
	+/* ARGSUSED */
	+int
	+backdel(int f, int n)
	+{
	+ int s;
	+
	+ if (n < 0)
	+ return (forwdel(f \| FFRAND, -n));
	+
	+ /* really a kill */
	+ if (f & FFARG) {
	+ if ((lastflag & CFKILL) == 0)
	+ kdelete();
	+ thisflag \|= CFKILL;
	+ }
	+ if ((s = backchar(f \| FFRAND, n)) == TRUE)
	+ s = ldelete((RSIZE)n, (f & FFARG) ? KFORW : KNONE);
	+
	+ return (s);
	+}
	+
	+#ifdef NOTAB
	+/* ARGSUSED */
	+int
	+space_to_tabstop(int f, int n)
	+{
	+ if (n < 0)
	+ return (FALSE);
	+ if (n == 0)
	+ return (TRUE);
	+ return (linsert((n << 3) - (curwp->w_doto & 7), ' '));
	+}
	+#endif /* NOTAB */
	+
	+/*
	+ * Move the dot to the first non-whitespace character of the current line.
	+ */
	+int
	+backtoindent(int f, int n)
	+{
	+ gotobol(FFRAND, 1);
	+ while (curwp->w_doto < llength(curwp->w_dotp) &&
	+ (isspace(lgetc(curwp->w_dotp, curwp->w_doto))))
	+ ++curwp->w_doto;
	+ return (TRUE);
	+}
	+
	+/*
	+ * Join the current line to the previous, or with arg, the next line
	+ * to the current one. If the former line is not empty, leave exactly
	+ * one space at the joint. Otherwise, leave no whitespace.
	+ */
	+int
	+joinline(int f, int n)
	+{
	+ int doto;
	+
	+ undo_boundary_enable(FFRAND, 0);
	+ if (f & FFARG) {
	+ gotoeol(FFRAND, 1);
	+ forwdel(FFRAND, 1);
	+ } else {
	+ gotobol(FFRAND, 1);
	+ backdel(FFRAND, 1);
	+ }
	+
	+ delwhite(FFRAND, 1);
	+
	+ if ((doto = curwp->w_doto) > 0) {
	+ linsert(1, ' ');
	+ curwp->w_doto = doto;
	+ }
	+ undo_boundary_enable(FFRAND, 1);
	+
	+ return (TRUE);
	+}
	Index: contrib/mg/version.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/version.c
	@@ -0,0 +1,28 @@
	+/* $OpenBSD: version.c,v 1.10 2015/03/19 21:22:15 bcallah Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * This file contains the string that gets written
	+ * out by the emacs-version command.
	+ */
	+
	+#include <sys/queue.h>
	+#include <signal.h>
	+#include <stdio.h>
	+
	+#include "def.h"
	+
	+const char version[] = "Mg 2a portable 7.0";
	+
	+/*
	+ * Display the version. All this does
	+ * is copy the version string onto the echo line.
	+ */
	+/* ARGSUSED */
	+int
	+showversion(int f, int n)
	+{
	+ ewprintf("%s", version);
	+ return (TRUE);
	+}
	Index: contrib/mg/window.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/window.c
	@@ -0,0 +1,440 @@
	+/* $OpenBSD: window.c,v 1.36 2015/11/18 18:21:06 jasper Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * Window handling.
	+ */
	+
	+#include <sys/queue.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+
	+#include "def.h"
	+
	+struct mgwin *
	+new_window(struct buffer *bp)
	+{
	+ struct mgwin *wp;
	+
	+ wp = calloc(1, sizeof(struct mgwin));
	+ if (wp == NULL)
	+ return (NULL);
	+
	+ wp->w_bufp = bp;
	+ wp->w_dotp = NULL;
	+ wp->w_doto = 0;
	+ wp->w_markp = NULL;
	+ wp->w_marko = 0;
	+ wp->w_rflag = 0;
	+ wp->w_frame = 0;
	+ wp->w_wrapline = NULL;
	+ wp->w_dotline = wp->w_markline = 1;
	+ if (bp)
	+ bp->b_nwnd++;
	+ return (wp);
	+}
	+
	+/*
	+ * Reposition dot in the current window to line "n". If the argument is
	+ * positive, it is that line. If it is negative it is that line from the
	+ * bottom. If it is 0 the window is centered (this is what the standard
	+ * redisplay code does).
	+ */
	+/* ARGSUSED */
	+int
	+reposition(int f, int n)
	+{
	+ curwp->w_frame = (f & FFARG) ? (n >= 0 ? n + 1 : n) : 0;
	+ curwp->w_rflag \|= WFFRAME;
	+ sgarbf = TRUE;
	+ return (TRUE);
	+}
	+
	+/*
	+ * Refresh the display. A call is made to the "ttresize" entry in the
	+ * terminal handler, which tries to reset "nrow" and "ncol". They will,
	+ * however, never be set outside of the NROW or NCOL range. If the display
	+ * changed size, arrange that everything is redone, then call "update" to
	+ * fix the display. We do this so the new size can be displayed. In the
	+ * normal case the call to "update" in "main.c" refreshes the screen, and
	+ * all of the windows need not be recomputed. This call includes a
	+ * 'force' parameter to ensure that the redraw is done, even after a
	+ * a suspend/continue (where the window size parameters will already
	+ * be updated). Note that when you get to the "display unusable"
	+ * message, the screen will be messed up. If you make the window bigger
	+ * again, and send another command, everything will get fixed!
	+ */
	+int
	+redraw(int f, int n)
	+{
	+ return (do_redraw(f, n, FALSE));
	+}
	+
	+/* ARGSUSED */
	+int
	+do_redraw(int f, int n, int force)
	+{
	+ struct mgwin *wp;
	+ int oldnrow, oldncol;
	+
	+ oldnrow = nrow;
	+ oldncol = ncol;
	+ ttresize();
	+ if (nrow != oldnrow \|\| ncol != oldncol \|\| force) {
	+
	+ /* find last */
	+ wp = wheadp;
	+ while (wp->w_wndp != NULL)
	+ wp = wp->w_wndp;
	+
	+ /* check if too small */
	+ if (nrow < wp->w_toprow + 3) {
	+ dobeep();
	+ ewprintf("Display unusable");
	+ return (FALSE);
	+ }
	+ wp->w_ntrows = nrow - wp->w_toprow - 2;
	+ sgarbf = TRUE;
	+ update(CMODE);
	+ } else
	+ sgarbf = TRUE;
	+ return (TRUE);
	+}
	+
	+/*
	+ * The command to make the next window (next => down the screen) the current
	+ * window. There are no real errors, although the command does nothing if
	+ * there is only 1 window on the screen.
	+ */
	+/* ARGSUSED */
	+int
	+nextwind(int f, int n)
	+{
	+ struct mgwin *wp;
	+
	+ if ((wp = curwp->w_wndp) == NULL)
	+ wp = wheadp;
	+ curwp = wp;
	+ curbp = wp->w_bufp;
	+ return (TRUE);
	+}
	+
	+/* not in GNU Emacs */
	+/*
	+ * This command makes the previous window (previous => up the screen) the
	+ * current window. There are no errors, although the command does not do
	+ * a lot if there is only 1 window.
	+ */
	+/* ARGSUSED */
	+int
	+prevwind(int f, int n)
	+{
	+ struct mgwin wp1, wp2;
	+
	+ wp1 = wheadp;
	+ wp2 = curwp;
	+ if (wp1 == wp2)
	+ wp2 = NULL;
	+ while (wp1->w_wndp != wp2)
	+ wp1 = wp1->w_wndp;
	+ curwp = wp1;
	+ curbp = wp1->w_bufp;
	+ return (TRUE);
	+}
	+
	+/*
	+ * This command makes the current window the only window on the screen. Try
	+ * to set the framing so that "." does not have to move on the display. Some
	+ * care has to be taken to keep the values of dot and mark in the buffer
	+ * structures right if the destruction of a window makes a buffer become
	+ * undisplayed.
	+ */
	+/* ARGSUSED */
	+int
	+onlywind(int f, int n)
	+{
	+ struct mgwin *wp;
	+ struct line *lp;
	+ int i;
	+
	+ while (wheadp != curwp) {
	+ wp = wheadp;
	+ wheadp = wp->w_wndp;
	+ if (--wp->w_bufp->b_nwnd == 0) {
	+ wp->w_bufp->b_dotp = wp->w_dotp;
	+ wp->w_bufp->b_doto = wp->w_doto;
	+ wp->w_bufp->b_markp = wp->w_markp;
	+ wp->w_bufp->b_marko = wp->w_marko;
	+ wp->w_bufp->b_dotline = wp->w_dotline;
	+ wp->w_bufp->b_markline = wp->w_markline;
	+ }
	+ free(wp);
	+ }
	+ while (curwp->w_wndp != NULL) {
	+ wp = curwp->w_wndp;
	+ curwp->w_wndp = wp->w_wndp;
	+ if (--wp->w_bufp->b_nwnd == 0) {
	+ wp->w_bufp->b_dotp = wp->w_dotp;
	+ wp->w_bufp->b_doto = wp->w_doto;
	+ wp->w_bufp->b_markp = wp->w_markp;
	+ wp->w_bufp->b_marko = wp->w_marko;
	+ wp->w_bufp->b_dotline = wp->w_dotline;
	+ wp->w_bufp->b_markline = wp->w_markline;
	+ }
	+ free(wp);
	+ }
	+ lp = curwp->w_linep;
	+ i = curwp->w_toprow;
	+ while (i != 0 && lback(lp) != curbp->b_headp) {
	+ --i;
	+ lp = lback(lp);
	+ }
	+ curwp->w_toprow = 0;
	+
	+ /* 2 = mode, echo */
	+ curwp->w_ntrows = nrow - 2;
	+ curwp->w_linep = lp;
	+ curwp->w_rflag \|= WFMODE \| WFFULL;
	+ return (TRUE);
	+}
	+
	+/*
	+ * Split the current window. A window smaller than 3 lines cannot be split.
	+ * The only other error that is possible is a "malloc" failure allocating the
	+ * structure for the new window.
	+ * If called with a FFOTHARG, flags on the new window are set to 'n'.
	+ */
	+/* ARGSUSED */
	+int
	+splitwind(int f, int n)
	+{
	+ struct mgwin wp, wp1, *wp2;
	+ struct line *lp;
	+ int ntru, ntrd, ntrl;
	+
	+ if (curwp->w_ntrows < 3) {
	+ dobeep();
	+ ewprintf("Cannot split a %d line window", curwp->w_ntrows);
	+ return (FALSE);
	+ }
	+ wp = new_window(curbp);
	+ if (wp == NULL) {
	+ dobeep();
	+ ewprintf("Unable to create a window");
	+ return (FALSE);
	+ }
	+
	+ /* use the current dot and mark */
	+ wp->w_dotp = curwp->w_dotp;
	+ wp->w_doto = curwp->w_doto;
	+ wp->w_markp = curwp->w_markp;
	+ wp->w_marko = curwp->w_marko;
	+ wp->w_dotline = curwp->w_dotline;
	+ wp->w_markline = curwp->w_markline;
	+
	+ /* figure out which half of the screen we're in */
	+ ntru = (curwp->w_ntrows - 1) / 2; /* Upper size */
	+ ntrl = (curwp->w_ntrows - 1) - ntru; /* Lower size */
	+
	+ for (lp = curwp->w_linep, ntrd = 0; lp != curwp->w_dotp;
	+ lp = lforw(lp))
	+ ntrd++;
	+
	+ lp = curwp->w_linep;
	+
	+ /* old is upper window */
	+ if (ntrd <= ntru) {
	+ /* hit mode line */
	+ if (ntrd == ntru)
	+ lp = lforw(lp);
	+ curwp->w_ntrows = ntru;
	+ wp->w_wndp = curwp->w_wndp;
	+ curwp->w_wndp = wp;
	+ wp->w_toprow = curwp->w_toprow + ntru + 1;
	+ wp->w_ntrows = ntrl;
	+ /* old is lower window */
	+ } else {
	+ wp1 = NULL;
	+ wp2 = wheadp;
	+ while (wp2 != curwp) {
	+ wp1 = wp2;
	+ wp2 = wp2->w_wndp;
	+ }
	+ if (wp1 == NULL)
	+ wheadp = wp;
	+ else
	+ wp1->w_wndp = wp;
	+ wp->w_wndp = curwp;
	+ wp->w_toprow = curwp->w_toprow;
	+ wp->w_ntrows = ntru;
	+
	+ /* mode line */
	+ ++ntru;
	+ curwp->w_toprow += ntru;
	+ curwp->w_ntrows = ntrl;
	+ while (ntru--)
	+ lp = lforw(lp);
	+ }
	+
	+ /* adjust the top lines if necessary */
	+ curwp->w_linep = lp;
	+ wp->w_linep = lp;
	+
	+ curwp->w_rflag \|= WFMODE \| WFFULL;
	+ wp->w_rflag \|= WFMODE \| WFFULL;
	+ /* if FFOTHARG, set flags) */
	+ if (f & FFOTHARG)
	+ wp->w_flag = n;
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * Enlarge the current window. Find the window that loses space. Make sure
	+ * it is big enough. If so, hack the window descriptions, and ask redisplay
	+ * to do all the hard work. You don't just set "force reframe" because dot
	+ * would move.
	+ */
	+/* ARGSUSED */
	+int
	+enlargewind(int f, int n)
	+{
	+ struct mgwin *adjwp;
	+ struct line *lp;
	+ int i;
	+
	+ if (n < 0)
	+ return (shrinkwind(f, -n));
	+ if (wheadp->w_wndp == NULL) {
	+ dobeep();
	+ ewprintf("Only one window");
	+ return (FALSE);
	+ }
	+ if ((adjwp = curwp->w_wndp) == NULL) {
	+ adjwp = wheadp;
	+ while (adjwp->w_wndp != curwp)
	+ adjwp = adjwp->w_wndp;
	+ }
	+ if (adjwp->w_ntrows <= n) {
	+ dobeep();
	+ ewprintf("Impossible change");
	+ return (FALSE);
	+ }
	+
	+ /* shrink below */
	+ if (curwp->w_wndp == adjwp) {
	+ lp = adjwp->w_linep;
	+ for (i = 0; i < n && lp != adjwp->w_bufp->b_headp; ++i)
	+ lp = lforw(lp);
	+ adjwp->w_linep = lp;
	+ adjwp->w_toprow += n;
	+ /* shrink above */
	+ } else {
	+ lp = curwp->w_linep;
	+ for (i = 0; i < n && lback(lp) != curbp->b_headp; ++i)
	+ lp = lback(lp);
	+ curwp->w_linep = lp;
	+ curwp->w_toprow -= n;
	+ }
	+ curwp->w_ntrows += n;
	+ adjwp->w_ntrows -= n;
	+ curwp->w_rflag \|= WFMODE \| WFFULL;
	+ adjwp->w_rflag \|= WFMODE \| WFFULL;
	+ return (TRUE);
	+}
	+
	+/*
	+ * Shrink the current window. Find the window that gains space. Hack at the
	+ * window descriptions. Ask the redisplay to do all the hard work.
	+ */
	+int
	+shrinkwind(int f, int n)
	+{
	+ struct mgwin *adjwp;
	+ struct line *lp;
	+ int i;
	+
	+ if (n < 0)
	+ return (enlargewind(f, -n));
	+ if (wheadp->w_wndp == NULL) {
	+ dobeep();
	+ ewprintf("Only one window");
	+ return (FALSE);
	+ }
	+ /*
	+ * Bit of flakiness - FFRAND means it was an internal call, and
	+ * to be trusted implicitly about sizes.
	+ */
	+ if (!(f & FFRAND) && curwp->w_ntrows <= n) {
	+ dobeep();
	+ ewprintf("Impossible change");
	+ return (FALSE);
	+ }
	+ if ((adjwp = curwp->w_wndp) == NULL) {
	+ adjwp = wheadp;
	+ while (adjwp->w_wndp != curwp)
	+ adjwp = adjwp->w_wndp;
	+ }
	+
	+ /* grow below */
	+ if (curwp->w_wndp == adjwp) {
	+ lp = adjwp->w_linep;
	+ for (i = 0; i < n && lback(lp) != adjwp->w_bufp->b_headp; ++i)
	+ lp = lback(lp);
	+ adjwp->w_linep = lp;
	+ adjwp->w_toprow -= n;
	+ /* grow above */
	+ } else {
	+ lp = curwp->w_linep;
	+ for (i = 0; i < n && lp != curbp->b_headp; ++i)
	+ lp = lforw(lp);
	+ curwp->w_linep = lp;
	+ curwp->w_toprow += n;
	+ }
	+ curwp->w_ntrows -= n;
	+ adjwp->w_ntrows += n;
	+ curwp->w_rflag \|= WFMODE \| WFFULL;
	+ adjwp->w_rflag \|= WFMODE \| WFFULL;
	+ return (TRUE);
	+}
	+
	+/*
	+ * Delete current window. Call shrink-window to do the screen updating, then
	+ * throw away the window.
	+ */
	+/* ARGSUSED */
	+int
	+delwind(int f, int n)
	+{
	+ struct mgwin wp, nwp;
	+
	+ wp = curwp; /* Cheap... */
	+
	+ /* shrinkwind returning false means only one window... */
	+ if (shrinkwind(FFRAND, wp->w_ntrows + 1) == FALSE)
	+ return (FALSE);
	+ if (--wp->w_bufp->b_nwnd == 0) {
	+ wp->w_bufp->b_dotp = wp->w_dotp;
	+ wp->w_bufp->b_doto = wp->w_doto;
	+ wp->w_bufp->b_markp = wp->w_markp;
	+ wp->w_bufp->b_marko = wp->w_marko;
	+ wp->w_bufp->b_dotline = wp->w_dotline;
	+ wp->w_bufp->b_markline = wp->w_markline;
	+ }
	+
	+ /* since shrinkwind did't crap out, we know we have a second window */
	+ if (wp == wheadp)
	+ wheadp = curwp = wp->w_wndp;
	+ else if ((curwp = wp->w_wndp) == NULL)
	+ curwp = wheadp;
	+ curbp = curwp->w_bufp;
	+ for (nwp = wheadp; nwp != NULL; nwp = nwp->w_wndp)
	+ if (nwp->w_wndp == wp) {
	+ nwp->w_wndp = wp->w_wndp;
	+ break;
	+ }
	+ free(wp);
	+ return (TRUE);
	+}
	Index: contrib/mg/word.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/word.c
	@@ -0,0 +1,514 @@
	+/* $OpenBSD: word.c,v 1.19 2015/12/30 20:51:51 lum Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * Word mode commands.
	+ * The routines in this file implement commands that work word at a time.
	+ * There are all sorts of word mode commands.
	+ */
	+
	+#include <sys/queue.h>
	+#include <signal.h>
	+#include <errno.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+
	+#include "def.h"
	+
	+RSIZE countfword(void);
	+int grabword(char **);
	+
	+/*
	+ * Move the cursor backward by "n" words. All of the details of motion are
	+ * performed by the "backchar" and "forwchar" routines.
	+ */
	+/* ARGSUSED */
	+int
	+backword(int f, int n)
	+{
	+ if (n < 0)
	+ return (forwword(f \| FFRAND, -n));
	+ if (backchar(FFRAND, 1) == FALSE)
	+ return (FALSE);
	+ while (n--) {
	+ while (inword() == FALSE) {
	+ if (backchar(FFRAND, 1) == FALSE)
	+ return (TRUE);
	+ }
	+ while (inword() != FALSE) {
	+ if (backchar(FFRAND, 1) == FALSE)
	+ return (TRUE);
	+ }
	+ }
	+ return (forwchar(FFRAND, 1));
	+}
	+
	+/*
	+ * Move the cursor forward by the specified number of words. All of the
	+ * motion is done by "forwchar".
	+ */
	+/* ARGSUSED */
	+int
	+forwword(int f, int n)
	+{
	+ if (n < 0)
	+ return (backword(f \| FFRAND, -n));
	+ while (n--) {
	+ while (inword() == FALSE) {
	+ if (forwchar(FFRAND, 1) == FALSE)
	+ return (TRUE);
	+ }
	+ while (inword() != FALSE) {
	+ if (forwchar(FFRAND, 1) == FALSE)
	+ return (TRUE);
	+ }
	+ }
	+ return (TRUE);
	+}
	+
	+/*
	+ * Transpose 2 words.
	+ * The function below is artifically restricted to only a maximum of 1 iteration
	+ * at the moment because the 'undo' functionality within mg needs amended for
	+ * multiple movements of point, backwards and forwards.
	+ */
	+int
	+transposeword(int f, int n)
	+{
	+ struct line *tmp1_w_dotp = NULL;
	+ struct line *tmp2_w_dotp = NULL;
	+ int tmp2_w_doto = 0;
	+ int tmp1_w_dotline = 0;
	+ int tmp2_w_dotline = 0;
	+ int tmp1_w_doto;
	+ int i; /* start-of-line space counter */
	+ int ret, s;
	+ int newline;
	+ int leave = 0;
	+ int tmp_len;
	+ char *word1 = NULL;
	+ char *word2 = NULL;
	+ char *chr;
	+
	+ if (n == 0)
	+ return (TRUE);
	+
	+ n = 1; /* remove this line to allow muliple-iterations */
	+
	+ if ((s = checkdirty(curbp)) != TRUE)
	+ return (s);
	+ if (curbp->b_flag & BFREADONLY) {
	+ dobeep();
	+ ewprintf("Buffer is read-only");
	+ return (FALSE);
	+ }
	+ undo_boundary_enable(FFRAND, 0);
	+
	+ /* go backwards to find the start of a word to transpose. */
	+ (void)backword(FFRAND, 1);
	+ ret = grabword(&word1);
	+ if (ret == ABORT) {
	+ ewprintf("No word to the left to tranpose.");
	+ return (FALSE);
	+ }
	+ if (ret < 0) {
	+ dobeep();
	+ ewprintf("Error copying word: %s", strerror(ret));
	+ free(word1);
	+ return (FALSE);
	+ }
	+
	+ while (n-- > 0) {
	+ i = 0;
	+ newline = 0;
	+
	+ tmp1_w_doto = curwp->w_doto;
	+ tmp1_w_dotline = curwp->w_dotline;
	+ tmp1_w_dotp = curwp->w_dotp;
	+
	+ /* go forward and find next word. */
	+ while (inword() == FALSE) {
	+ if (forwchar(FFRAND, 1) == FALSE) {
	+ leave = 1;
	+ if (tmp1_w_dotline < curwp->w_dotline)
	+ curwp->w_dotline--;
	+ ewprintf("Don't have two things to transpose");
	+ break;
	+ }
	+ if (curwp->w_doto == 0) {
	+ newline = 1;
	+ i = 0;
	+ } else if (newline)
	+ i++;
	+ }
	+ if (leave) {
	+ tmp2_w_doto = tmp1_w_doto;
	+ tmp2_w_dotline = tmp1_w_dotline;
	+ tmp2_w_dotp = tmp1_w_dotp;
	+ break;
	+ }
	+ tmp2_w_doto = curwp->w_doto;
	+ tmp2_w_dotline = curwp->w_dotline;
	+ tmp2_w_dotp = curwp->w_dotp;
	+
	+ ret = grabword(&word2);
	+ if (ret < 0 \|\| ret == ABORT) {
	+ dobeep();
	+ ewprintf("Error copying word: %s", strerror(ret));
	+ free(word1);
	+ return (FALSE);
	+ }
	+ tmp_len = strlen(word2);
	+ tmp2_w_doto += tmp_len;
	+
	+ curwp->w_doto = tmp1_w_doto;
	+ curwp->w_dotline = tmp1_w_dotline;
	+ curwp->w_dotp = tmp1_w_dotp;
	+
	+ /* insert shuffled along word */
	+ for (chr = word2; *chr != '\0'; ++chr)
	+ linsert(1, *chr);
	+
	+ if (newline)
	+ tmp2_w_doto = i;
	+
	+ curwp->w_doto = tmp2_w_doto;
	+ curwp->w_dotline = tmp2_w_dotline;
	+ curwp->w_dotp = tmp2_w_dotp;
	+
	+ word2 = NULL;
	+ }
	+ curwp->w_doto = tmp2_w_doto;
	+ curwp->w_dotline = tmp2_w_dotline;
	+ curwp->w_dotp = tmp2_w_dotp;
	+
	+ /* insert very first word in its new position */
	+ for (chr = word1; *chr != '\0'; ++chr)
	+ linsert(1, *chr);
	+
	+ if (leave)
	+ (void)backword(FFRAND, 1);
	+
	+ free(word1);
	+ free(word2);
	+
	+ undo_boundary_enable(FFRAND, 1);
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * copy and delete word.
	+*/
	+int
	+grabword(char **word)
	+{
	+ int c;
	+
	+ while (inword() == TRUE) {
	+ c = lgetc(curwp->w_dotp, curwp->w_doto);
	+ if (*word == NULL) {
	+ if (asprintf(word, "%c", c) == -1)
	+ return (errno);
	+ } else {
	+ if (asprintf(word, "%s%c", *word, c) == -1)
	+ return (errno);
	+ }
	+ (void)forwdel(FFRAND, 1);
	+ }
	+ if (*word == NULL)
	+ return (ABORT);
	+ return (TRUE);
	+}
	+
	+/*
	+ * Move the cursor forward by the specified number of words. As you move,
	+ * convert any characters to upper case.
	+ */
	+/* ARGSUSED */
	+int
	+upperword(int f, int n)
	+{
	+ int c, s;
	+ RSIZE size;
	+
	+ if ((s = checkdirty(curbp)) != TRUE)
	+ return (s);
	+ if (curbp->b_flag & BFREADONLY) {
	+ dobeep();
	+ ewprintf("Buffer is read-only");
	+ return (FALSE);
	+ }
	+
	+ if (n < 0)
	+ return (FALSE);
	+ while (n--) {
	+ while (inword() == FALSE) {
	+ if (forwchar(FFRAND, 1) == FALSE)
	+ return (TRUE);
	+ }
	+ size = countfword();
	+ undo_add_change(curwp->w_dotp, curwp->w_doto, size);
	+
	+ while (inword() != FALSE) {
	+ c = lgetc(curwp->w_dotp, curwp->w_doto);
	+ if (ISLOWER(c) != FALSE) {
	+ c = TOUPPER(c);
	+ lputc(curwp->w_dotp, curwp->w_doto, c);
	+ lchange(WFFULL);
	+ }
	+ if (forwchar(FFRAND, 1) == FALSE)
	+ return (TRUE);
	+ }
	+ }
	+ return (TRUE);
	+}
	+
	+/*
	+ * Move the cursor forward by the specified number of words. As you move
	+ * convert characters to lower case.
	+ */
	+/* ARGSUSED */
	+int
	+lowerword(int f, int n)
	+{
	+ int c, s;
	+ RSIZE size;
	+
	+ if ((s = checkdirty(curbp)) != TRUE)
	+ return (s);
	+ if (curbp->b_flag & BFREADONLY) {
	+ dobeep();
	+ ewprintf("Buffer is read-only");
	+ return (FALSE);
	+ }
	+ if (n < 0)
	+ return (FALSE);
	+ while (n--) {
	+ while (inword() == FALSE) {
	+ if (forwchar(FFRAND, 1) == FALSE)
	+ return (TRUE);
	+ }
	+ size = countfword();
	+ undo_add_change(curwp->w_dotp, curwp->w_doto, size);
	+
	+ while (inword() != FALSE) {
	+ c = lgetc(curwp->w_dotp, curwp->w_doto);
	+ if (ISUPPER(c) != FALSE) {
	+ c = TOLOWER(c);
	+ lputc(curwp->w_dotp, curwp->w_doto, c);
	+ lchange(WFFULL);
	+ }
	+ if (forwchar(FFRAND, 1) == FALSE)
	+ return (TRUE);
	+ }
	+ }
	+ return (TRUE);
	+}
	+
	+/*
	+ * Move the cursor forward by the specified number of words. As you move
	+ * convert the first character of the word to upper case, and subsequent
	+ * characters to lower case. Error if you try to move past the end of the
	+ * buffer.
	+ */
	+/* ARGSUSED */
	+int
	+capword(int f, int n)
	+{
	+ int c, s;
	+ RSIZE size;
	+
	+ if ((s = checkdirty(curbp)) != TRUE)
	+ return (s);
	+ if (curbp->b_flag & BFREADONLY) {
	+ dobeep();
	+ ewprintf("Buffer is read-only");
	+ return (FALSE);
	+ }
	+
	+ if (n < 0)
	+ return (FALSE);
	+ while (n--) {
	+ while (inword() == FALSE) {
	+ if (forwchar(FFRAND, 1) == FALSE)
	+ return (TRUE);
	+ }
	+ size = countfword();
	+ undo_add_change(curwp->w_dotp, curwp->w_doto, size);
	+
	+ if (inword() != FALSE) {
	+ c = lgetc(curwp->w_dotp, curwp->w_doto);
	+ if (ISLOWER(c) != FALSE) {
	+ c = TOUPPER(c);
	+ lputc(curwp->w_dotp, curwp->w_doto, c);
	+ lchange(WFFULL);
	+ }
	+ if (forwchar(FFRAND, 1) == FALSE)
	+ return (TRUE);
	+ while (inword() != FALSE) {
	+ c = lgetc(curwp->w_dotp, curwp->w_doto);
	+ if (ISUPPER(c) != FALSE) {
	+ c = TOLOWER(c);
	+ lputc(curwp->w_dotp, curwp->w_doto, c);
	+ lchange(WFFULL);
	+ }
	+ if (forwchar(FFRAND, 1) == FALSE)
	+ return (TRUE);
	+ }
	+ }
	+ }
	+ return (TRUE);
	+}
	+
	+/*
	+ * Count characters in word, from current position
	+ */
	+RSIZE
	+countfword()
	+{
	+ RSIZE size;
	+ struct line *dotp;
	+ int doto;
	+
	+ dotp = curwp->w_dotp;
	+ doto = curwp->w_doto;
	+ size = 0;
	+
	+ while (inword() != FALSE) {
	+ if (forwchar(FFRAND, 1) == FALSE)
	+ /* hit the end of the buffer */
	+ goto out;
	+ ++size;
	+ }
	+out:
	+ curwp->w_dotp = dotp;
	+ curwp->w_doto = doto;
	+ return (size);
	+}
	+
	+
	+/*
	+ * Kill forward by "n" words.
	+ */
	+/* ARGSUSED */
	+int
	+delfword(int f, int n)
	+{
	+ RSIZE size;
	+ struct line *dotp;
	+ int doto;
	+ int s;
	+
	+ if ((s = checkdirty(curbp)) != TRUE)
	+ return (s);
	+ if (curbp->b_flag & BFREADONLY) {
	+ dobeep();
	+ ewprintf("Buffer is read-only");
	+ return (FALSE);
	+ }
	+ if (n < 0)
	+ return (FALSE);
	+
	+ /* purge kill buffer */
	+ if ((lastflag & CFKILL) == 0)
	+ kdelete();
	+
	+ thisflag \|= CFKILL;
	+ dotp = curwp->w_dotp;
	+ doto = curwp->w_doto;
	+ size = 0;
	+
	+ while (n--) {
	+ while (inword() == FALSE) {
	+ if (forwchar(FFRAND, 1) == FALSE)
	+ /* hit the end of the buffer */
	+ goto out;
	+ ++size;
	+ }
	+ while (inword() != FALSE) {
	+ if (forwchar(FFRAND, 1) == FALSE)
	+ /* hit the end of the buffer */
	+ goto out;
	+ ++size;
	+ }
	+ }
	+out:
	+ curwp->w_dotp = dotp;
	+ curwp->w_doto = doto;
	+ return (ldelete(size, KFORW));
	+}
	+
	+/*
	+ * Kill backwards by "n" words. The rules for success and failure are now
	+ * different, to prevent strange behavior at the start of the buffer. The
	+ * command only fails if something goes wrong with the actual delete of the
	+ * characters. It is successful even if no characters are deleted, or if you
	+ * say delete 5 words, and there are only 4 words left. I considered making
	+ * the first call to "backchar" special, but decided that that would just be
	+ * weird. Normally this is bound to "M-Rubout" and to "M-Backspace".
	+ */
	+/* ARGSUSED */
	+int
	+delbword(int f, int n)
	+{
	+ RSIZE size;
	+ int s;
	+
	+ if ((s = checkdirty(curbp)) != TRUE)
	+ return (s);
	+ if (curbp->b_flag & BFREADONLY) {
	+ dobeep();
	+ ewprintf("Buffer is read-only");
	+ return (FALSE);
	+ }
	+
	+ if (n < 0)
	+ return (FALSE);
	+
	+ /* purge kill buffer */
	+ if ((lastflag & CFKILL) == 0)
	+ kdelete();
	+ thisflag \|= CFKILL;
	+ if (backchar(FFRAND, 1) == FALSE)
	+ /* hit buffer start */
	+ return (TRUE);
	+
	+ /* one deleted */
	+ size = 1;
	+ while (n--) {
	+ while (inword() == FALSE) {
	+ if (backchar(FFRAND, 1) == FALSE)
	+ /* hit buffer start */
	+ goto out;
	+ ++size;
	+ }
	+ while (inword() != FALSE) {
	+ if (backchar(FFRAND, 1) == FALSE)
	+ /* hit buffer start */
	+ goto out;
	+ ++size;
	+ }
	+ }
	+ if (forwchar(FFRAND, 1) == FALSE)
	+ return (FALSE);
	+
	+ /* undo assumed delete */
	+ --size;
	+out:
	+ return (ldelete(size, KBACK));
	+}
	+
	+/*
	+ * Return TRUE if the character at dot is a character that is considered to be
	+ * part of a word. The word character list is hard coded. Should be settable.
	+ */
	+int
	+inword(void)
	+{
	+ /* can't use lgetc in ISWORD due to bug in OSK cpp */
	+ return (curwp->w_doto != llength(curwp->w_dotp) &&
	+ ISWORD(curwp->w_dotp->l_text[curwp->w_doto]));
	+}
	Index: contrib/mg/yank.c
	===================================================================
	--- /dev/null
	+++ contrib/mg/yank.c
	@@ -0,0 +1,267 @@
	+/* $OpenBSD: yank.c,v 1.15 2021/03/01 10:51:14 lum Exp $ */
	+
	+/* This file is in the public domain. */
	+
	+/*
	+ * kill ring functions
	+ */
	+
	+#include <sys/queue.h>
	+#include <signal.h>
	+#include <stdio.h>
	+#include <stdlib.h>
	+#include <string.h>
	+
	+#include "def.h"
	+
	+#define KBLOCK 8192 /* Kill grow. */
	+
	+static char kbufp = NULL; / Kill buffer data. */
	+static RSIZE kused = 0; /* # of bytes used in KB. */
	+static RSIZE ksize = 0; /* # of bytes allocated in KB. */
	+static RSIZE kstart = 0; /* # of first used byte in KB. */
	+
	+static int kgrow(int);
	+
	+/*
	+ * Delete all of the text saved in the kill buffer. Called by commands when
	+ * a new kill context is created. The kill buffer array is released, just in
	+ * case the buffer has grown to an immense size. No errors.
	+ */
	+void
	+kdelete(void)
	+{
	+ if (kbufp != NULL) {
	+ free(kbufp);
	+ kbufp = NULL;
	+ kstart = kused = ksize = 0;
	+ }
	+}
	+
	+/*
	+ * Insert a character to the kill buffer, enlarging the buffer if there
	+ * isn't any room. Always grow the buffer in chunks, on the assumption
	+ * that if you put something in the kill buffer you are going to put more
	+ * stuff there too later. Return TRUE if all is well, and FALSE on errors.
	+ * Print a message on errors. Dir says whether to put it at back or front.
	+ * This call is ignored if KNONE is set.
	+ */
	+int
	+kinsert(int c, int dir)
	+{
	+ if (dir == KNONE)
	+ return (TRUE);
	+ if (kused == ksize && dir == KFORW && kgrow(dir) == FALSE)
	+ return (FALSE);
	+ if (kstart == 0 && dir == KBACK && kgrow(dir) == FALSE)
	+ return (FALSE);
	+ if (dir == KFORW)
	+ kbufp[kused++] = c;
	+ else if (dir == KBACK)
	+ kbufp[--kstart] = c;
	+ else
	+ panic("broken kinsert call"); /* Oh shit! */
	+ return (TRUE);
	+}
	+
	+/*
	+ * kgrow - just get more kill buffer for the callee. If dir = KBACK
	+ * we are trying to get space at the beginning of the kill buffer.
	+ */
	+static int
	+kgrow(int dir)
	+{
	+ int nstart;
	+ char *nbufp;
	+
	+ if ((unsigned)(ksize + KBLOCK) <= (unsigned)ksize) {
	+ /* probably 16 bit unsigned */
	+ dobeep();
	+ ewprintf("Kill buffer size at maximum");
	+ return (FALSE);
	+ }
	+ if ((nbufp = malloc((unsigned)(ksize + KBLOCK))) == NULL) {
	+ dobeep();
	+ ewprintf("Can't get %ld bytes", (long)(ksize + KBLOCK));
	+ return (FALSE);
	+ }
	+ nstart = (dir == KBACK) ? (kstart + KBLOCK) : (KBLOCK / 4);
	+ bcopy(&(kbufp[kstart]), &(nbufp[nstart]), (int)(kused - kstart));
	+ free(kbufp);
	+ kbufp = nbufp;
	+ ksize += KBLOCK;
	+ kused = kused - kstart + nstart;
	+ kstart = nstart;
	+ return (TRUE);
	+}
	+
	+/*
	+ * This function gets characters from the kill buffer. If the character
	+ * index "n" is off the end, it returns "-1". This lets the caller just
	+ * scan along until it gets a "-1" back.
	+ */
	+int
	+kremove(int n)
	+{
	+ if (n < 0 \|\| n + kstart >= kused)
	+ return (-1);
	+ return (CHARMASK(kbufp[n + kstart]));
	+}
	+
	+/*
	+ * Copy a string into the kill buffer. kflag gives direction.
	+ * if KNONE, do nothing.
	+ */
	+int
	+kchunk(char *cp1, RSIZE chunk, int kflag)
	+{
	+ /*
	+ * HACK - doesn't matter, and fixes back-over-nl bug for empty
	+ * kill buffers.
	+ */
	+ if (kused == kstart)
	+ kflag = KFORW;
	+
	+ if (kflag & KFORW) {
	+ while (ksize - kused < chunk)
	+ if (kgrow(kflag) == FALSE)
	+ return (FALSE);
	+ bcopy(cp1, &(kbufp[kused]), (int)chunk);
	+ kused += chunk;
	+ } else if (kflag & KBACK) {
	+ while (kstart < chunk)
	+ if (kgrow(kflag) == FALSE)
	+ return (FALSE);
	+ bcopy(cp1, &(kbufp[kstart - chunk]), (int)chunk);
	+ kstart -= chunk;
	+ }
	+
	+ return (TRUE);
	+}
	+
	+/*
	+ * Kill line. If called without an argument, it kills from dot to the end
	+ * of the line, unless it is at the end of the line, when it kills the
	+ * newline. If called with an argument of 0, it kills from the start of the
	+ * line to dot. If called with a positive argument, it kills from dot
	+ * forward over that number of newlines. If called with a negative argument
	+ * it kills any text before dot on the current line, then it kills back
	+ * abs(arg) lines.
	+ */
	+/* ARGSUSED */
	+int
	+killline(int f, int n)
	+{
	+ struct line *nextp;
	+ RSIZE chunk;
	+ int i, c;
	+
	+ /* clear kill buffer if last wasn't a kill */
	+ if ((lastflag & CFKILL) == 0)
	+ kdelete();
	+ thisflag \|= CFKILL;
	+ if (!(f & FFARG)) {
	+ for (i = curwp->w_doto; i < llength(curwp->w_dotp); ++i)
	+ if ((c = lgetc(curwp->w_dotp, i)) != ' ' && c != '\t')
	+ break;
	+ if (i == llength(curwp->w_dotp))
	+ chunk = llength(curwp->w_dotp) - curwp->w_doto + 1;
	+ else {
	+ chunk = llength(curwp->w_dotp) - curwp->w_doto;
	+ if (chunk == 0)
	+ chunk = 1;
	+ }
	+ } else if (n > 0) {
	+ chunk = llength(curwp->w_dotp) - curwp->w_doto;
	+ nextp = lforw(curwp->w_dotp);
	+ if (nextp != curbp->b_headp)
	+ chunk++; /* newline */
	+ if (nextp == curbp->b_headp)
	+ goto done; /* EOL */
	+ i = n;
	+ while (--i) {
	+ chunk += llength(nextp);
	+ nextp = lforw(nextp);
	+ if (nextp != curbp->b_headp)
	+ chunk++; /* newline */
	+ if (nextp == curbp->b_headp)
	+ break; /* EOL */
	+ }
	+ } else {
	+ /* n <= 0 */
	+ chunk = curwp->w_doto;
	+ curwp->w_doto = 0;
	+ i = n;
	+ while (i++) {
	+ if (lforw(curwp->w_dotp))
	+ chunk++;
	+ curwp->w_dotp = lback(curwp->w_dotp);
	+ curwp->w_rflag \|= WFMOVE;
	+ chunk += llength(curwp->w_dotp);
	+ }
	+ }
	+ /*
	+ * KFORW here is a bug. Should be KBACK/KFORW, but we need to
	+ * rewrite the ldelete code (later)?
	+ */
	+done:
	+ if (chunk)
	+ return (ldelete(chunk, KFORW));
	+ return (TRUE);
	+}
	+
	+/*
	+ * Yank text back from the kill buffer. This is really easy. All of the work
	+ * is done by the standard insert routines. All you do is run the loop, and
	+ * check for errors. The blank lines are inserted with a call to "newline"
	+ * instead of a call to "lnewline" so that the magic stuff that happens when
	+ * you type a carriage return also happens when a carriage return is yanked
	+ * back from the kill buffer. An attempt has been made to fix the cosmetic
	+ * bug associated with a yank when dot is on the top line of the window
	+ * (nothing moves, because all of the new text landed off screen).
	+ */
	+/* ARGSUSED */
	+int
	+yank(int f, int n)
	+{
	+ struct line *lp;
	+ int c, i, nline;
	+
	+ if (n < 0)
	+ return (FALSE);
	+
	+ /* newline counting */
	+ nline = 0;
	+
	+ undo_boundary_enable(FFRAND, 0);
	+ while (n--) {
	+ /* mark around last yank */
	+ isetmark();
	+ i = 0;
	+ while ((c = kremove(i)) >= 0) {
	+ if (c == *curbp->b_nlchr) {
	+ if (enewline(FFRAND, 1) == FALSE)
	+ return (FALSE);
	+ ++nline;
	+ } else {
	+ if (linsert(1, c) == FALSE)
	+ return (FALSE);
	+ }
	+ ++i;
	+ }
	+ }
	+ /* cosmetic adjustment */
	+ lp = curwp->w_linep;
	+
	+ /* if offscreen insert */
	+ if (curwp->w_dotp == lp) {
	+ while (nline-- && lback(lp) != curbp->b_headp)
	+ lp = lback(lp);
	+ /* adjust framing */
	+ curwp->w_linep = lp;
	+ curwp->w_rflag \|= WFFULL;
	+ }
	+ undo_boundary_enable(FFRAND, 1);
	+ return (TRUE);
	+}
	+
	Index: release/packages/Makefile.package
	===================================================================
	--- release/packages/Makefile.package
	+++ release/packages/Makefile.package
	@@ -79,6 +79,8 @@
	kernel_DESC= FreeBSD Kernel
	manuals_COMMENT= Manual Pages
	manuals_DESC= Manual Pages
	+mg_COMMENT= Small, fast Emacs-like editor
	+mg_DESC= Small, fast Emacs-like editor
	mlx-tools_COMMENT= Mellanox Utilities
	mlx-tools_DESC= Mellanox Utilities
	mtree_COMMENT= MTREE Files
	Index: usr.bin/Makefile
	===================================================================
	--- usr.bin/Makefile
	+++ usr.bin/Makefile
	@@ -89,6 +89,7 @@
	m4 \
	mandoc \
	mesg \
	+ mg \
	minigzip \
	ministat \
	mkdep \
	Index: usr.bin/mg/Makefile
	===================================================================
	--- /dev/null
	+++ usr.bin/mg/Makefile
	@@ -0,0 +1,64 @@
	+PACKAGE= mg
	+PROG= mg
	+SRCDIR= ${SRCTOP}/contrib/mg
	+
	+.PATH: ${SRCDIR}
	+
	+CFLAGS+= -DREGEX -w -D__dead=__dead2 -DLOGIN_NAME_MAX=MAXLOGNAME
	+CFLAGS+= -I${.CURDIR} -I${SRCDIR}
	+CWARNFLAGS+= -w
	+
	+LIBADD= util ncursesw
	+
	+SRCS= autoexec.c \
	+ basic.c \
	+ bell.c \
	+ buffer.c \
	+ cinfo.c \
	+ dir.c \
	+ display.c \
	+ echo.c \
	+ extend.c \
	+ file.c \
	+ fileio.c \
	+ funmap.c \
	+ help.c \
	+ kbd.c \
	+ keymap.c \
	+ line.c \
	+ macro.c \
	+ main.c \
	+ match.c \
	+ modes.c \
	+ paragraph.c \
	+ re_search.c \
	+ region.c \
	+ search.c \
	+ spawn.c \
	+ tty.c \
	+ ttyio.c \
	+ ttykbd.c \
	+ undo.c \
	+ util.c \
	+ version.c \
	+ window.c \
	+ word.c \
	+ yank.c \
	+ cmode.c \
	+ cscope.c \
	+ dired.c \
	+ grep.c \
	+ tags.c \
	+ fparseln.c \
	+ fstatat.c \
	+ futimens.c \
	+ getline.c \
	+ reallocarray.c \
	+ strlcat.c \
	+ strlcpy.c \
	+ strndup.c \
	+ strtonum.c \
	+ interpreter.c \
	+ extensions.c
	+
	+.include <bsd.prog.mk>
	Index: usr.bin/mg/config.h
	===================================================================
	--- /dev/null
	+++ usr.bin/mg/config.h
	@@ -0,0 +1,14 @@
	+/* This file is based on the file generated by configure. */
	+
	+#include "common.h"
	+#include "freebsd.h"
	+
	+#define HAVE_FPARSELN
	+#define HAVE_FSTATAT
	+#define HAVE_FUTIMENS
	+#define HAVE_GETLINE
	+#define HAVE_REALLOCARRAY
	+#define HAVE_STRLCAT
	+#define HAVE_STRLCPY
	+#define HAVE_STRNDUP
	+#define HAVE_STRTONUM

File Metadata

Mime Type: text/plain
Expires: Sat, Nov 14, 2:14 AM (14 h, 59 m)
Storage Engine: local-disk
Storage Format: Raw Data
Storage Handle: 66/41/577e72d1c349a5014fce2754c326
Default Alt Text: D34411.1794622443.diff (997 KB)

D34411.1794622443.diffNo OneTemporaryActions

D34411.1794622443.diffView Options

File Metadata

Event Timeline

D34411.1794622443.diff
No OneTemporary
Actions

D34411.1794622443.diff
View Options