path: root/patches/ed.patch

Index: editors/Makefile.in
===================================================================
--- editors/Makefile.in	(revision 10144)
+++ editors/Makefile.in	(working copy)
@@ -24,8 +24,9 @@
 srcdir=$(top_srcdir)/editors
 
 EDITOR-y:=
-EDITOR-$(CONFIG_AWK)	   += awk.o
-EDITOR-$(CONFIG_PATCH)	   += patch.o
+EDITOR-$(CONFIG_AWK)       += awk.o
+EDITOR-$(CONFIG_ED)        += ed.o
+EDITOR-$(CONFIG_PATCH)     += patch.o
 EDITOR-$(CONFIG_SED)       += sed.o
 EDITOR-$(CONFIG_VI)        += vi.o
 EDITOR_SRC:= $(EDITOR-y)
Index: editors/Config.in
===================================================================
--- editors/Config.in	(revision 10144)
+++ editors/Config.in	(working copy)
@@ -20,6 +20,12 @@
 	  Enable math functions of the Awk programming language.
 	  NOTE: This will require libm to be present for linking.
 
+config CONFIG_ED
+	bool "ed"
+	default n
+	help
+	  ed
+
 config CONFIG_PATCH
 	bool "patch"
 	default n
Index: include/usage.h
===================================================================
--- include/usage.h	(revision 10151)
+++ include/usage.h	(working copy)
@@ -556,6 +561,9 @@
 	"$ echo \"Erik\\nis\\ncool\"\n" \
 	"Erik\\nis\\ncool\n")
 
+#define ed_trivial_usage ""
+#define ed_full_usage ""
+
 #define env_trivial_usage \
 	"[-iu] [-] [name=value]... [command]"
 #define env_full_usage \
Index: include/applets.h
===================================================================
--- include/applets.h	(revision 10151)
+++ include/applets.h	(working copy)
@@ -179,6 +179,9 @@
 #ifdef CONFIG_ECHO
 	APPLET(echo, echo_main, _BB_DIR_BIN, _BB_SUID_NEVER)
 #endif
+#ifdef CONFIG_ED
+	APPLET(ed, ed_main, _BB_DIR_BIN, _BB_SUID_NEVER)
+#endif
 #if defined(CONFIG_FEATURE_GREP_EGREP_ALIAS)
 	APPLET_NOUSAGE("egrep", grep_main, _BB_DIR_BIN, _BB_SUID_NEVER)
 #endif
--- /dev/null	2005-04-22 11:15:01.120978184 -0400
+++ editors/ed.c	2005-04-22 11:16:00.000000000 -0400
@@ -0,0 +1,3120 @@
+/* main.c: This file contains the main control and user-interface routines
+   for the ed line editor. */
+/* ed line editor.
+   Copyright (C) 1993, 1994 Andrew Moore, Talke Studio
+   All Rights Reserved
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+/*
+ * CREDITS
+ *
+ *      This program is based on the editor algorithm described in
+ *      Brian W. Kernighan and P. J. Plauger's book "Software Tools
+ *      in Pascal," Addison-Wesley, 1981.
+ *
+ *      The buffering algorithm is attributed to Rodney Ruddock of
+ *      the University of Guelph, Guelph, Ontario.
+ *
+ */
+
+#include <errno.h>
+#include <limits.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+#include <setjmp.h>
+#include <pwd.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/file.h>
+#include <sys/ioctl.h>
+
+#include "busybox.h"
+#include "ed.h"
+#include "getopt.h"
+
+jmp_buf env;
+
+/* static buffers */
+char *errmsg;			/* error message buffer */
+char stdinbuf[1];		/* stdin buffer */
+char *shcmd;			/* shell command buffer */
+int shcmdsz;			/* shell command buffer size */
+int shcmdi;			/* shell command buffer index */
+char *ibuf;			/* ed command-line buffer */
+int ibufsz;			/* ed command-line buffer size */
+char *ibufp;			/* pointer to ed command-line buffer */
+
+/* global flags */
+int traditional = 0;		/* if set, be backwards compatible */
+int garrulous = 0;		/* if set, print all error messages */
+int isbinary;			/* if set, buffer contains ASCII NULs */
+int isglobal;			/* if set, doing a global command */
+int modified;			/* if set, buffer modified since last write */
+int mutex = 0;			/* if set, signals set "sigflags" */
+int red = 0;			/* if set, restrict shell/directory access */
+int scripted = 0;		/* if set, suppress diagnostics */
+int sigactive = 0;		/* if set, signal handlers are enabled */
+int sigflags = 0;		/* if set, signals received while mutex set */
+
+char *old_filename;		/* default filename */
+long current_addr;		/* current address in editor buffer */
+long addr_last;			/* last address in editor buffer */
+int lineno;			/* script line number */
+char *prompt;			/* command-line prompt */
+char *dps = "*";		/* default command-line prompt */
+long err_status = 0;		/* program exit status */
+
+/* The name this program was run with. */
+char *program_name;
+
+/* If non-zero, display usage information and exit.  */
+int show_help = 0;
+
+/* If non-zero, print the version on standard output and exit.  */
+int show_version = 0;
+
+/* Long options equivalences.  */
+struct option long_options[] =
+{
+  {"help", no_argument, &show_help, 1},
+  {"prompt", required_argument, NULL, 'p'},
+  {"quiet", no_argument, NULL, 's'},
+  {"silent", no_argument, NULL, 's'},
+  {"traditional", no_argument, NULL, 'G'},
+  {"version", no_argument, &show_version, 1},
+  {0, 0, 0, 0},
+};
+
+extern int optind;
+extern char *optarg;
+
+/* usage: explain usage */
+
+#if 0
+void
+usage (status)
+     int status;
+{
+  if (status != 0)
+    fprintf (stderr, "Try `%s --help' for more information.\n", program_name);
+  else
+    {
+      printf ("Usage: %s [OPTION]... [FILE]\n", program_name);
+      printf ("\
+\n\
+  -G, --traditional          use a few backward compatible features\n\
+  -p, --prompt=STRING        use STRING as an interactive prompt\n\
+  -s, -, --quiet, --silent   suppress diagnostics\n");
+      printf ("\
+      --help                 display this help\n\
+      --version              output version information\n\
+\n\
+Start edit by reading in FILE if given.  Read output of shell command\n\
+if FILE begins with a `!'.\n");
+    }
+  exit (status);
+}
+#endif
+#define usage(x) bb_show_usage()
+
+
+/* ed: line editor */
+int
+ed_main (int argc, char **argv)
+{
+  int c, n;
+  long status = 0;
+
+  program_name = argv[0];
+  red = (n = strlen (argv[0])) > 2 && argv[0][n - 3] == 'r';
+top:
+  while ((c = getopt_long (argc, argv, "Gp:s", long_options, NULL)) != EOF)
+    switch (c)
+      {
+      default:
+	usage (1);
+      case 0:
+	break;
+      case 'G':			/* backward compatibility */
+	traditional = 1;
+	break;
+      case 'p':			/* set prompt */
+	prompt = optarg;
+	break;
+      case 's':			/* run script */
+	scripted = 1;
+	break;
+      }
+  if (show_help)
+    usage (0);
+  argv += optind;
+  argc -= optind;
+  if (argc && **argv == '-')
+    {
+      scripted = 1;
+      if (argc > 1)
+	{
+	  optind = 0;
+	  goto top;
+	}
+      argv++;
+      argc--;
+    }
+  init_buffers ();
+
+  /* assert: reliable signals! */
+#ifdef SIGWINCH
+  handle_winch (SIGWINCH);
+  if (isatty (0))
+    reliable_signal (SIGWINCH, handle_winch);
+#endif
+  reliable_signal (SIGHUP, signal_hup);
+  reliable_signal (SIGQUIT, SIG_IGN);
+  reliable_signal (SIGINT, signal_int);
+  if ((status = setjmp (env)))
+    {
+      fputs ("\n?\n", stderr);
+      sprintf (errmsg, "Interrupt");
+    }
+  else
+    {
+      sigactive = 1;		/* enable signal handlers */
+      if (argc && **argv && is_legal_filename (*argv))
+	{
+	  if (read_file (*argv, 0) < 0 && is_regular_file (0))
+	    quit (2);
+	  else if (**argv != '!')
+	    strcpy (old_filename, *argv);
+	}
+      else if (argc)
+	{
+	  fputs ("?\n", stderr);
+	  if (**argv == '\0')
+	    sprintf (errmsg, "Invalid filename");
+	  if (is_regular_file (0))
+	    quit (2);
+	}
+    }
+  for (;;)
+    {
+      if (status < 0 && garrulous)
+	fprintf (stderr, "%s\n", errmsg);
+      if (prompt)
+	{
+	  printf ("%s", prompt);
+	  fflush (stdout);
+	}
+      if ((n = get_tty_line ()) < 0)
+	{
+	  status = ERR;
+	  continue;
+	}
+      else if (n == 0)
+	{
+	  if (modified && !scripted)
+	    {
+	      fputs ("?\n", stderr);
+	      sprintf (errmsg, "Warning: file modified");
+	      if (is_regular_file (0))
+		{
+		  fprintf (stderr, garrulous ?
+			   "script, line %d: %s\n" :
+			   "", lineno, errmsg);
+		  quit (2);
+		}
+	      clearerr (stdin);
+	      modified = 0;
+	      status = EMOD;
+	      continue;
+	    }
+	  else
+	    quit (err_status);
+	}
+      else if (ibuf[n - 1] != '\n')
+	{
+	  /* discard line */
+	  sprintf (errmsg, "Unexpected end-of-file");
+	  clearerr (stdin);
+	  status = ERR;
+	  continue;
+	}
+      isglobal = 0;
+      if ((status = extract_addr_range ()) >= 0 &&
+	  (status = exec_command ()) >= 0)
+	if (!status || (status = display_lines (current_addr, current_addr,
+						status)) >= 0)
+	  continue;
+      switch (status)
+	{
+	case EOF:
+	  quit (err_status);
+	case EMOD:
+	  modified = 0;
+	  fputs ("?\n", stderr);	/* give warning */
+	  sprintf (errmsg, "Warning: file modified");
+	  if (is_regular_file (0))
+	    {
+	      fprintf (stderr, garrulous ?
+		       "script, line %d: %s\n" :
+		       "", lineno, errmsg);
+	      quit (2);
+	    }
+	  break;
+	case FATAL:
+	  if (is_regular_file (0))
+	    fprintf (stderr, garrulous ?
+		     "script, line %d: %s\n" : "",
+		     lineno, errmsg);
+	  else
+	    fprintf (stderr, garrulous ? "%s\n" : "",
+		     errmsg);
+	  quit (3);
+	default:
+	  fputs ("?\n", stderr);
+	  if (is_regular_file (0))
+	    {
+	      fprintf (stderr, garrulous ?
+		       "script, line %d: %s\n" : "",
+		       lineno, errmsg);
+	      quit (4);
+	    }
+	  break;
+	}
+	err_status = -status;
+    }
+  /*NOTREACHED */
+}
+
+long first_addr, second_addr, addr_cnt;
+
+/* extract_addr_range: get line addresses from the command buffer until an
+   illegal address is seen; return status */
+int
+extract_addr_range ()
+{
+  long addr;
+
+  addr_cnt = 0;
+  first_addr = second_addr = current_addr;
+  while ((addr = next_addr ()) >= 0)
+    {
+      addr_cnt++;
+      first_addr = second_addr;
+      second_addr = addr;
+      if (*ibufp != ',' && *ibufp != ';')
+	break;
+      else if (*ibufp++ == ';')
+	current_addr = addr;
+    }
+  if ((addr_cnt = min (addr_cnt, 2)) == 1 || second_addr != addr)
+    first_addr = second_addr;
+  return (addr == ERR) ? ERR : 0;
+}
+
+
+#define SKIP_BLANKS() \
+  while (isspace (*ibufp) && *ibufp != '\n')				\
+    ibufp++
+
+#define MUST_BE_FIRST() \
+  do 									\
+    {									\
+      if (!first)							\
+	{								\
+	  sprintf (errmsg, "Invalid address");				\
+	  return ERR;							\
+	}								\
+    }									\
+  while (0)
+
+/*  next_addr: return the next line address in the command buffer */
+long
+next_addr ()
+{
+  char *hd;
+  long addr = current_addr;
+  long n;
+  int first = 1;
+  int c;
+
+  SKIP_BLANKS ();
+  for (hd = ibufp;; first = 0)
+    switch (c = *ibufp)
+      {
+      case '+':
+      case '\t':
+      case ' ':
+      case '-':
+      case '^':
+	ibufp++;
+	SKIP_BLANKS ();
+	if (isdigit (*ibufp))
+	  {
+	    STRTOL (n, ibufp);
+	    addr += (c == '-' || c == '^') ? -n : n;
+	  }
+	else if (!isspace (c))
+	  addr += (c == '-' || c == '^') ? -1 : 1;
+	break;
+      case '0':
+      case '1':
+      case '2':
+      case '3':
+      case '4':
+      case '5':
+      case '6':
+      case '7':
+      case '8':
+      case '9':
+	MUST_BE_FIRST ();
+	STRTOL (addr, ibufp);
+	break;
+      case '.':
+      case '$':
+	MUST_BE_FIRST ();
+	ibufp++;
+	addr = (c == '.') ? current_addr : addr_last;
+	break;
+      case '/':
+      case '?':
+	MUST_BE_FIRST ();
+	if ((addr = get_matching_node_addr (
+				    get_compiled_pattern (), c == '/')) < 0)
+	  return ERR;
+	else if (c == *ibufp)
+	  ibufp++;
+	break;
+      case '\'':
+	MUST_BE_FIRST ();
+	ibufp++;
+	if ((addr = get_marked_node_addr (*ibufp++)) < 0)
+	  return ERR;
+	break;
+      case '%':
+      case ',':
+      case ';':
+	if (first)
+	  {
+	    ibufp++;
+	    addr_cnt++;
+	    second_addr = (c == ';') ? current_addr : 1;
+	    addr = addr_last;
+	    break;
+	  }
+	/* FALL THROUGH */
+      default:
+	if (ibufp == hd)
+	  return EOF;
+	else if (addr < 0 || addr_last < addr)
+	  {
+	    sprintf (errmsg, "Invalid address");
+	    return ERR;
+	  }
+	else
+	  return addr;
+      }
+  /* NOTREACHED */
+}
+
+
+/* GET_THIRD_ADDR: get a legal address from the command buffer */
+#define GET_THIRD_ADDR(addr) \
+  do									\
+    {									\
+      long ol1, ol2;							\
+      ol1 = first_addr, ol2 = second_addr;				\
+      if (extract_addr_range () < 0)					\
+	return ERR;							\
+      else if (traditional && addr_cnt == 0)				\
+	{								\
+	  sprintf (errmsg, "Destination expected");			\
+	  return ERR;							\
+	}								\
+      else if (second_addr < 0 || addr_last < second_addr)		\
+	{								\
+	  sprintf (errmsg, "Invalid address");				\
+	  return ERR;							\
+	}								\
+      (addr) = second_addr;						\
+      first_addr = ol1, second_addr = ol2;				\
+    }									\
+  while (0)
+
+/* GET_COMMAND_SUFFIX: verify the command suffix in the command buffer */
+#define GET_COMMAND_SUFFIX() \
+  do									\
+    {									\
+      int done = 0;							\
+      do								\
+	{								\
+	  switch (*ibufp)						\
+	    {								\
+	    case 'p':							\
+	      gflag |= GPR, ibufp++;					\
+	      break;							\
+	    case 'l':							\
+	      gflag |= GLS, ibufp++;					\
+	      break;							\
+	    case 'n':							\
+	      gflag |= GNP, ibufp++;					\
+	      break;							\
+	    default:							\
+	      done++;							\
+	    }								\
+	}								\
+      while (!done);							\
+      if (*ibufp++ != '\n')						\
+	{								\
+	  sprintf (errmsg, "Invalid command suffix");			\
+	  return ERR;							\
+	}								\
+    }									\
+  while (0)
+
+/* sflags */
+#define SGG 001			/* complement previous global substitute suffix */
+#define SGP 002			/* complement previous print suffix */
+#define SGR 004			/* use last regex instead of last pat */
+#define SGF 010			/* repeat last substitution */
+
+int patlock = 0;		/* if set, pattern not freed by get_compiled_pattern() */
+
+long rows = 22;			/* scroll length: ws_row - 2 */
+
+/* exec_command: execute the next command in command buffer; return print
+   request, if any */
+int
+exec_command ()
+{
+  extern long u_current_addr;
+  extern long u_addr_last;
+
+  static pattern_t *pat = NULL;
+  static int sgflag = 0;
+  static int sgnum = 0;
+
+  pattern_t *tpat;
+  char *fnp;
+  int gflag = 0;
+  int sflags = 0;
+  long addr = 0;
+  int n = 0;
+  int c;
+
+  SKIP_BLANKS ();
+  switch (c = *ibufp++)
+    {
+    case 'a':
+      GET_COMMAND_SUFFIX ();
+      if (!isglobal)
+	clear_undo_stack ();
+      if (append_lines (second_addr) < 0)
+	return ERR;
+      break;
+    case 'c':
+      if (check_addr_range (current_addr, current_addr) < 0)
+	return ERR;
+      GET_COMMAND_SUFFIX ();
+      if (!isglobal)
+	clear_undo_stack ();
+      if (delete_lines (first_addr, second_addr) < 0 ||
+	  append_lines (current_addr) < 0)
+	return ERR;
+      break;
+    case 'd':
+      if (check_addr_range (current_addr, current_addr) < 0)
+	return ERR;
+      GET_COMMAND_SUFFIX ();
+      if (!isglobal)
+	clear_undo_stack ();
+      if (delete_lines (first_addr, second_addr) < 0)
+	return ERR;
+      else if ((addr = INC_MOD (current_addr, addr_last)) != 0)
+	current_addr = addr;
+      break;
+    case 'e':
+      if (modified && !scripted)
+	return EMOD;
+      /* fall through */
+    case 'E':
+      if (addr_cnt > 0)
+	{
+	  sprintf (errmsg, "Unexpected address");
+	  return ERR;
+	}
+      else if (!isspace (*ibufp))
+	{
+	  sprintf (errmsg, "Unexpected command suffix");
+	  return ERR;
+	}
+      else if ((fnp = get_filename ()) == NULL)
+	return ERR;
+      GET_COMMAND_SUFFIX ();
+      if (delete_lines (1, addr_last) < 0)
+	return ERR;
+      delete_yank_lines ();
+      clear_undo_stack ();
+      if (close_sbuf () < 0)
+	return ERR;
+      else if (open_sbuf () < 0)
+	return FATAL;
+      if (*fnp && *fnp != '!')
+	strcpy (old_filename, fnp);
+      if (traditional && *fnp == '\0' && *old_filename == '\0')
+	{
+	  sprintf (errmsg, "No current filename");
+	  return ERR;
+	}
+      else if (read_file (*fnp ? fnp : old_filename, 0) < 0)
+	return ERR;
+      clear_undo_stack ();
+      modified = 0;
+      u_current_addr = u_addr_last = -1;
+      break;
+    case 'f':
+      if (addr_cnt > 0)
+	{
+	  sprintf (errmsg, "Unexpected address");
+	  return ERR;
+	}
+      else if (!isspace (*ibufp))
+	{
+	  sprintf (errmsg, "Unexpected command suffix");
+	  return ERR;
+	}
+      else if ((fnp = get_filename ()) == NULL)
+	return ERR;
+      else if (*fnp == '!')
+	{
+	  sprintf (errmsg, "Invalid redirection");
+	  return ERR;
+	}
+      GET_COMMAND_SUFFIX ();
+      if (*fnp)
+	strcpy (old_filename, fnp);
+      printf ("%s\n", strip_escapes (old_filename));
+      break;
+    case 'g':
+    case 'v':
+    case 'G':
+    case 'V':
+      if (isglobal)
+	{
+	  sprintf (errmsg, "Cannot nest global commands");
+	  return ERR;
+	}
+      else if (check_addr_range (1, addr_last) < 0)
+	return ERR;
+      else if (build_active_list (c == 'g' || c == 'G') < 0)
+	return ERR;
+      else if ((n = (c == 'G' || c == 'V')))
+	GET_COMMAND_SUFFIX ();
+      isglobal++;
+      if (exec_global (n, gflag) < 0)
+	return ERR;
+      break;
+    case 'h':
+      if (addr_cnt > 0)
+	{
+	  sprintf (errmsg, "Unexpected address");
+	  return ERR;
+	}
+      GET_COMMAND_SUFFIX ();
+      if (*errmsg)
+	fprintf (stderr, "%s\n", errmsg);
+      break;
+    case 'H':
+      if (addr_cnt > 0)
+	{
+	  sprintf (errmsg, "Unexpected address");
+	  return ERR;
+	}
+      GET_COMMAND_SUFFIX ();
+      if ((garrulous = 1 - garrulous) && *errmsg)
+	fprintf (stderr, "%s\n", errmsg);
+      break;
+    case 'i':
+      if (second_addr == 0)
+	{
+	  sprintf (errmsg, "Invalid address");
+	  return ERR;
+	}
+      GET_COMMAND_SUFFIX ();
+      if (!isglobal)
+	clear_undo_stack ();
+      if (append_lines (second_addr - 1) < 0)
+	return ERR;
+      break;
+    case 'j':
+      if (check_addr_range (current_addr, current_addr + 1) < 0)
+	return ERR;
+      GET_COMMAND_SUFFIX ();
+      if (!isglobal)
+	clear_undo_stack ();
+      if (first_addr != second_addr &&
+	  join_lines (first_addr, second_addr) < 0)
+	return ERR;
+      break;
+    case 'k':
+      c = *ibufp++;
+      if (second_addr == 0)
+	{
+	  sprintf (errmsg, "Invalid address");
+	  return ERR;
+	}
+      GET_COMMAND_SUFFIX ();
+      if (mark_line_node (get_addressed_line_node (second_addr), c) < 0)
+	return ERR;
+      break;
+    case 'l':
+      if (check_addr_range (current_addr, current_addr) < 0)
+	return ERR;
+      GET_COMMAND_SUFFIX ();
+      if (display_lines (first_addr, second_addr, gflag | GLS) < 0)
+	return ERR;
+      gflag = 0;
+      break;
+    case 'm':
+      if (check_addr_range (current_addr, current_addr) < 0)
+	return ERR;
+      GET_THIRD_ADDR (addr);
+      if (first_addr <= addr && addr < second_addr)
+	{
+	  sprintf (errmsg, "Invalid destination");
+	  return ERR;
+	}
+      GET_COMMAND_SUFFIX ();
+      if (!isglobal)
+	clear_undo_stack ();
+      if (move_lines (addr) < 0)
+	return ERR;
+      break;
+    case 'n':
+      if (check_addr_range (current_addr, current_addr) < 0)
+	return ERR;
+      GET_COMMAND_SUFFIX ();
+      if (display_lines (first_addr, second_addr, gflag | GNP) < 0)
+	return ERR;
+      gflag = 0;
+      break;
+    case 'p':
+      if (check_addr_range (current_addr, current_addr) < 0)
+	return ERR;
+      GET_COMMAND_SUFFIX ();
+      if (display_lines (first_addr, second_addr, gflag | GPR) < 0)
+	return ERR;
+      gflag = 0;
+      break;
+    case 'P':
+      if (addr_cnt > 0)
+	{
+	  sprintf (errmsg, "Unexpected address");
+	  return ERR;
+	}
+      GET_COMMAND_SUFFIX ();
+      prompt = prompt ? NULL : optarg ? optarg : dps;
+      break;
+    case 'q':
+    case 'Q':
+      if (addr_cnt > 0)
+	{
+	  sprintf (errmsg, "Unexpected address");
+	  return ERR;
+	}
+      GET_COMMAND_SUFFIX ();
+      gflag = (modified && !scripted && c == 'q') ? EMOD : EOF;
+      break;
+    case 'r':
+      if (!isspace (*ibufp))
+	{
+	  sprintf (errmsg, "Unexpected command suffix");
+	  return ERR;
+	}
+      else if (addr_cnt == 0)
+	second_addr = addr_last;
+      if ((fnp = get_filename ()) == NULL)
+	return ERR;
+      GET_COMMAND_SUFFIX ();
+      if (!isglobal)
+	clear_undo_stack ();
+      if (*old_filename == '\0' && *fnp != '!')
+	strcpy (old_filename, fnp);
+      if (traditional && *fnp == '\0' && *old_filename == '\0')
+	{
+	  sprintf (errmsg, "No current filename");
+	  return ERR;
+	}
+      if ((addr = read_file (*fnp ? fnp : old_filename, second_addr)) < 0)
+	return ERR;
+      else if (addr && addr != addr_last)
+	modified = 1;
+      break;
+    case 's':
+      do
+	{
+	  switch (*ibufp)
+	    {
+	    case '\n':
+	      sflags |= SGF;
+	      break;
+	    case 'g':
+	      sflags |= SGG;
+	      ibufp++;
+	      break;
+	    case 'p':
+	      sflags |= SGP;
+	      ibufp++;
+	      break;
+	    case 'r':
+	      sflags |= SGR;
+	      ibufp++;
+	      break;
+	    case '0':
+	    case '1':
+	    case '2':
+	    case '3':
+	    case '4':
+	    case '5':
+	    case '6':
+	    case '7':
+	    case '8':
+	    case '9': {
+			long sgnum_long;
+	      STRTOL (sgnum_long, ibufp);
+		sgnum = sgnum_long;
+	      sflags |= SGF;
+	      sgflag &= ~GSG;	/* override GSG */
+	      break;
+		}
+	    default:
+	      if (sflags)
+		{
+		  sprintf (errmsg, "Invalid command suffix");
+		  return ERR;
+		}
+	    }
+	}
+      while (sflags && *ibufp != '\n');
+      if (sflags && !pat)
+	{
+	  sprintf (errmsg, "No previous substitution");
+	  return ERR;
+	}
+      else if (sflags & SGG)
+	sgnum = 0;		/* override numeric arg */
+      if (*ibufp != '\n' && *(ibufp + 1) == '\n')
+	{
+	  sprintf (errmsg, "Invalid pattern delimiter");
+	  return ERR;
+	}
+      tpat = pat;
+      SPL1 ();
+      if ((!sflags || (sflags & SGR)) &&
+	  (tpat = get_compiled_pattern ()) == NULL)
+	{
+	  SPL0 ();
+	  return ERR;
+	}
+      else if (tpat != pat)
+	{
+	  if (pat)
+	    {
+	      regfree (pat);
+	      free (pat);
+	    }
+	  pat = tpat;
+	  patlock = 1;		/* reserve pattern */
+	}
+      SPL0 ();
+      if (!sflags && extract_subst_tail (&sgflag, &sgnum) < 0)
+	return ERR;
+      else if (isglobal)
+	sgflag |= GLB;
+      else
+	sgflag &= ~GLB;
+      if (sflags & SGG)
+	sgflag ^= GSG;
+      if (sflags & SGP)
+	sgflag ^= GPR, sgflag &= ~(GLS | GNP);
+      do
+	{
+	  switch (*ibufp)
+	    {
+	    case 'p':
+	      sgflag |= GPR, ibufp++;
+	      break;
+	    case 'l':
+	      sgflag |= GLS, ibufp++;
+	      break;
+	    case 'n':
+	      sgflag |= GNP, ibufp++;
+	      break;
+	    default:
+	      n++;
+	    }
+	}
+      while (!n);
+      if (check_addr_range (current_addr, current_addr) < 0)
+	return ERR;
+      GET_COMMAND_SUFFIX ();
+      if (!isglobal)
+	clear_undo_stack ();
+      if (search_and_replace (pat, sgflag, sgnum) < 0)
+	return ERR;
+      break;
+    case 't':
+      if (check_addr_range (current_addr, current_addr) < 0)
+	return ERR;
+      GET_THIRD_ADDR (addr);
+      GET_COMMAND_SUFFIX ();
+      if (!isglobal)
+	clear_undo_stack ();
+      if (copy_lines (addr) < 0)
+	return ERR;
+      break;
+    case 'u':
+      if (addr_cnt > 0)
+	{
+	  sprintf (errmsg, "Unexpected address");
+	  return ERR;
+	}
+      GET_COMMAND_SUFFIX ();
+      if (pop_undo_stack () < 0)
+	return ERR;
+      break;
+    case 'w':
+    case 'W':
+      if ((n = *ibufp) == 'q' || n == 'Q')
+	{
+	  gflag = EOF;
+	  ibufp++;
+	}
+      if (!isspace (*ibufp))
+	{
+	  sprintf (errmsg, "Unexpected command suffix");
+	  return ERR;
+	}
+      else if ((fnp = get_filename ()) == NULL)
+	return ERR;
+      if (addr_cnt == 0 && !addr_last)
+	first_addr = second_addr = 0;
+      else if (check_addr_range (1, addr_last) < 0)
+	return ERR;
+      GET_COMMAND_SUFFIX ();
+      if (*old_filename == '\0' && *fnp != '!')
+	strcpy (old_filename, fnp);
+      if (traditional && *fnp == '\0' && *old_filename == '\0')
+	{
+	  sprintf (errmsg, "No current filename");
+	  return ERR;
+	}
+      if ((addr = write_file (*fnp ? fnp : old_filename,
+		      (c == 'W') ? "a" : "w", first_addr, second_addr)) < 0)
+	return ERR;
+      else if (addr == addr_last)
+	modified = 0;
+      else if (modified && !scripted && n == 'q')
+	gflag = EMOD;
+      break;
+    case 'x':
+      if (second_addr < 0 || addr_last < second_addr)
+	{
+	  sprintf (errmsg, "Invalid address");
+	  return ERR;
+	}
+      GET_COMMAND_SUFFIX ();
+      if (!isglobal)
+	clear_undo_stack ();
+      if (put_lines (second_addr) < 0)
+	return ERR;
+      break;
+    case 'y':
+      if (check_addr_range (current_addr, current_addr) < 0)
+	return ERR;
+      GET_COMMAND_SUFFIX ();
+      if (yank_lines (first_addr, second_addr) < 0)
+	return ERR;
+      break;
+    case 'z':
+      if (check_addr_range
+         (first_addr = 1, current_addr + (traditional ? 1 : !isglobal)) < 0)
+	return ERR;
+      else if ('0' < *ibufp && *ibufp <= '9')
+	STRTOL (rows, ibufp);
+      GET_COMMAND_SUFFIX ();
+      if (display_lines (second_addr, min (addr_last,
+					   second_addr + rows), gflag) < 0)
+	return ERR;
+      gflag = 0;
+      break;
+    case '=':
+      GET_COMMAND_SUFFIX ();
+      printf ("%ld\n", addr_cnt ? second_addr : addr_last);
+      break;
+    case '!':
+      if (addr_cnt > 0)
+	{
+	  sprintf (errmsg, "Unexpected address");
+	  return ERR;
+	}
+      else if ((sflags = get_shell_command ()) < 0)
+	return ERR;
+      GET_COMMAND_SUFFIX ();
+      if (sflags)
+	printf ("%s\n", shcmd + 1);
+      system (shcmd + 1);
+      if (!scripted)
+	printf ("!\n");
+      break;
+    case '\n':
+      if (check_addr_range
+         (first_addr = 1, current_addr + (traditional ? 1 : !isglobal)) < 0 ||
+         display_lines (second_addr, second_addr, 0) < 0)
+	return ERR;
+      break;
+    case '#':
+      while (*ibufp++ != '\n')
+	 ;
+      break;
+    default:
+      sprintf (errmsg, "Unknown command");
+      return ERR;
+    }
+  return gflag;
+}
+
+
+/* check_addr_range: return status of address range check */
+int
+check_addr_range (n, m)
+     long n, m;
+{
+  if (addr_cnt == 0)
+    {
+      first_addr = n;
+      second_addr = m;
+    }
+  if (first_addr > second_addr || 1 > first_addr ||
+      second_addr > addr_last)
+    {
+      sprintf (errmsg, "Invalid address");
+      return ERR;
+    }
+  return 0;
+}
+
+
+/* get_matching_node_addr: return the address of the next line matching a
+   pattern in a given direction.  wrap around begin/end of editor buffer if
+   necessary */
+long
+get_matching_node_addr (pat, dir)
+     pattern_t *pat;
+     int dir;
+{
+  char *s;
+  long n = current_addr;
+  line_t *lp;
+
+  if (!pat)
+    return ERR;
+  do
+    {
+      if ((n = dir ? INC_MOD (n, addr_last) : DEC_MOD (n, addr_last)))
+	{
+	  lp = get_addressed_line_node (n);
+	  if ((s = get_sbuf_line (lp)) == NULL)
+	    return ERR;
+	  if (isbinary)
+	    NUL_TO_NEWLINE (s, lp->len);
+	  if (!regexec (pat, s, 0, NULL, 0))
+	    return n;
+	}
+    }
+  while (n != current_addr);
+  sprintf (errmsg, "No match");
+  return ERR;
+}
+
+
+/* get_filename: return pointer to copy of filename in the command buffer */
+char *
+get_filename ()
+{
+  static char *file = NULL;
+  static int filesz = 0;
+
+  int n;
+
+  if (*ibufp != '\n')
+    {
+      SKIP_BLANKS ();
+      if (*ibufp == '\n')
+	{
+	  sprintf (errmsg, "Invalid filename");
+	  return NULL;
+	}
+      else if ((ibufp = get_extended_line (&n, 1)) == NULL)
+	return NULL;
+      else if (*ibufp == '!')
+	{
+	  ibufp++;
+	  if ((n = get_shell_command ()) < 0)
+	    return NULL;
+	  if (n)
+	    printf ("%s\n", shcmd + 1);
+	  return shcmd;
+	}
+      else if (n > PATH_MAX)
+	{
+	  sprintf (errmsg, "Filename too long");
+	  return NULL;
+	}
+    }
+  else if (!traditional && *old_filename == '\0')
+    {
+      sprintf (errmsg, "No current filename");
+      return NULL;
+    }
+  REALLOC (file, filesz, PATH_MAX + 1, NULL);
+  for (n = 0; *ibufp != '\n';)
+    file[n++] = *ibufp++;
+  file[n] = '\0';
+  return is_legal_filename (file) ? file : NULL;
+}
+
+
+/* get_shell_command: read a shell command from stdin; return substitution
+   status */
+int
+get_shell_command ()
+{
+  static char *buf = NULL;
+  static int n = 0;
+
+  char *s;			/* substitution char pointer */
+  int i = 0;
+  int j = 0;
+
+  if (red)
+    {
+      sprintf (errmsg, "Shell access restricted");
+      return ERR;
+    }
+  else if ((s = ibufp = get_extended_line (&j, 1)) == NULL)
+    return ERR;
+  REALLOC (buf, n, j + 1, ERR);
+  buf[i++] = '!';		/* prefix command w/ bang */
+  while (*ibufp != '\n')
+    switch (*ibufp)
+      {
+      default:
+	REALLOC (buf, n, i + 2, ERR);
+	buf[i++] = *ibufp;
+	if (*ibufp++ == '\\')
+	  buf[i++] = *ibufp++;
+	break;
+      case '!':
+	if (s != ibufp)
+	  {
+	    REALLOC (buf, n, i + 1, ERR);
+	    buf[i++] = *ibufp++;
+	  }
+	else if (shcmd == NULL || (traditional && *(shcmd + 1) == '\0'))
+	  {
+	    sprintf (errmsg, "No previous command");
+	    return ERR;
+	  }
+	else
+	  {
+	    REALLOC (buf, n, i + shcmdi, ERR);
+	    for (s = shcmd + 1; s < shcmd + shcmdi;)
+	      buf[i++] = *s++;
+	    s = ibufp++;
+	  }
+	break;
+      case '%':
+	if (*old_filename == '\0')
+	  {
+	    sprintf (errmsg, "No current filename");
+	    return ERR;
+	  }
+	j = strlen (s = strip_escapes (old_filename));
+	REALLOC (buf, n, i + j, ERR);
+	while (j--)
+	  buf[i++] = *s++;
+	s = ibufp++;
+	break;
+      }
+  REALLOC (shcmd, shcmdsz, i + 1, ERR);
+  memcpy (shcmd, buf, i);
+  shcmd[shcmdi = i] = '\0';
+  return *s == '!' || *s == '%';
+}
+
+
+/* append_lines: insert text from stdin to after line n; stop when either a
+   single period is read or EOF; return status */
+int
+append_lines (n)
+     long n;
+{
+  int l;
+  char *lp = ibuf;
+  char *eot;
+  undo_t *up = NULL;
+
+  for (current_addr = n;;)
+    {
+      if (!isglobal)
+	{
+	  if ((l = get_tty_line ()) < 0)
+	    return ERR;
+	  else if (l == 0 || ibuf[l - 1] != '\n')
+	    {
+	      clearerr (stdin);
+	      return l ? EOF : 0;
+	    }
+	  lp = ibuf;
+	}
+      else if (*(lp = ibufp) == '\0')
+	return 0;
+      else
+	{
+	  while (*ibufp++ != '\n')
+	    ;
+	  l = ibufp - lp;
+	}
+      if (l == 2 && lp[0] == '.' && lp[1] == '\n')
+	{
+	  return 0;
+	}
+      eot = lp + l;
+      SPL1 ();
+      do
+	{
+	  if ((lp = put_sbuf_line (lp)) == NULL)
+	    {
+	      SPL0 ();
+	      return ERR;
+	    }
+	  else if (up)
+	    up->t = get_addressed_line_node (current_addr);
+	  else if ((up = push_undo_stack (UADD, current_addr,
+					  current_addr)) == NULL)
+	    {
+	      SPL0 ();
+	      return ERR;
+	    }
+	}
+      while (lp != eot);
+      modified = 1;
+      SPL0 ();
+    }
+  /* NOTREACHED */
+}
+
+
+/* join_lines: replace a range of lines with the joined text of those lines */
+int
+join_lines (from, to)
+     long from;
+     long to;
+{
+  static char *buf = NULL;
+  static int n;
+
+  char *s;
+  int size = 0;
+  line_t *bp, *ep;
+
+  ep = get_addressed_line_node (INC_MOD (to, addr_last));
+  bp = get_addressed_line_node (from);
+  for (; bp != ep; bp = bp->q_forw)
+    {
+      if ((s = get_sbuf_line (bp)) == NULL)
+	return ERR;
+      REALLOC (buf, n, size + bp->len, ERR);
+      memcpy (buf + size, s, bp->len);
+      size += bp->len;
+    }
+  REALLOC (buf, n, size + 2, ERR);
+  memcpy (buf + size, "\n", 2);
+  if (delete_lines (from, to) < 0)
+    return ERR;
+  current_addr = from - 1;
+  SPL1 ();
+  if (put_sbuf_line (buf) == NULL ||
+      push_undo_stack (UADD, current_addr, current_addr) == NULL)
+    {
+      SPL0 ();
+      return ERR;
+    }
+  modified = 1;
+  SPL0 ();
+  return 0;
+}
+
+
+/* move_lines: move a range of lines */
+int
+move_lines (addr)
+     long addr;
+{
+  line_t *b1, *a1, *b2, *a2;
+  long n = INC_MOD (second_addr, addr_last);
+  long p = first_addr - 1;
+  int done = (addr == first_addr - 1 || addr == second_addr);
+
+  SPL1 ();
+  if (done)
+    {
+      a2 = get_addressed_line_node (n);
+      b2 = get_addressed_line_node (p);
+      current_addr = second_addr;
+    }
+  else if (push_undo_stack (UMOV, p, n) == NULL ||
+	   push_undo_stack (UMOV, addr, INC_MOD (addr, addr_last)) == NULL)
+    {
+      SPL0 ();
+      return ERR;
+    }
+  else
+    {
+      a1 = get_addressed_line_node (n);
+      if (addr < first_addr)
+	{
+	  b1 = get_addressed_line_node (p);
+	  b2 = get_addressed_line_node (addr);
+	  /* this get_addressed_line_node last! */
+	}
+      else
+	{
+	  b2 = get_addressed_line_node (addr);
+	  b1 = get_addressed_line_node (p);
+	  /* this get_addressed_line_node last! */
+	}
+      a2 = b2->q_forw;
+      REQUE (b2, b1->q_forw);
+      REQUE (a1->q_back, a2);
+      REQUE (b1, a1);
+      current_addr = addr + ((addr < first_addr) ?
+			     second_addr - first_addr + 1 : 0);
+    }
+  if (isglobal)
+    unset_active_nodes (b2->q_forw, a2);
+  modified = 1;
+  SPL0 ();
+  return 0;
+}
+
+
+/* copy_lines: copy a range of lines; return status */
+int
+copy_lines (addr)
+     long addr;
+{
+  line_t *lp, *np = get_addressed_line_node (first_addr);
+  undo_t *up = NULL;
+  long n = second_addr - first_addr + 1;
+  long m = 0;
+
+  current_addr = addr;
+  if (first_addr <= addr && addr < second_addr)
+    {
+      n = addr - first_addr + 1;
+      m = second_addr - addr;
+    }
+  for (; n > 0; n = m, m = 0, np = get_addressed_line_node (current_addr + 1))
+    for (; n-- > 0; np = np->q_forw)
+      {
+	SPL1 ();
+	if ((lp = dup_line_node (np)) == NULL)
+	  {
+	    SPL0 ();
+	    return ERR;
+	  }
+	add_line_node (lp);
+	if (up)
+	  up->t = lp;
+	else if ((up = push_undo_stack (UADD, current_addr,
+					current_addr)) == NULL)
+	  {
+	    SPL0 ();
+	    return ERR;
+	  }
+	modified = 1;
+	SPL0 ();
+      }
+  return 0;
+}
+
+
+/* delete_lines: delete a range of lines */
+int
+delete_lines (from, to)
+     long from, to;
+{
+  line_t *n, *p;
+
+  if (yank_lines (from, to) < 0)
+    return ERR;
+  SPL1 ();
+  if (push_undo_stack (UDEL, from, to) == NULL)
+    {
+      SPL0 ();
+      return ERR;
+    }
+  n = get_addressed_line_node (INC_MOD (to, addr_last));
+  p = get_addressed_line_node (from - 1);
+  /* this get_addressed_line_node last! */
+  if (isglobal)
+    unset_active_nodes (p->q_forw, n);
+  REQUE (p, n);
+  addr_last -= to - from + 1;
+  current_addr = from - 1;
+  modified = 1;
+  SPL0 ();
+  return 0;
+}
+
+
+int dlcnt = 0;				/* # of lines displayed */
+
+/* display_lines: print a range of lines to stdout */
+int
+display_lines (from, to, gflag)
+     long from;
+     long to;
+     int gflag;
+{
+  line_t *bp;
+  line_t *ep;
+  char *s;
+
+  if (!from)
+    {
+      sprintf (errmsg, "Invalid address");
+      return ERR;
+    }
+  ep = get_addressed_line_node (INC_MOD (to, addr_last));
+  bp = get_addressed_line_node (from);
+  for (dlcnt = 0; bp != ep; bp = bp->q_forw)
+    {
+      if ((s = get_sbuf_line (bp)) == NULL)
+	return ERR;
+      else if (put_tty_line (s, bp->len, current_addr = from++, gflag) < 0)
+	return ERR;
+      else if (!traditional && !scripted && !isglobal &&
+	       bp->q_forw != ep && ++dlcnt > rows)
+	{
+	  dlcnt = 0;
+	  fputs ("Press <RETURN> to continue... ", stdout);
+	  fflush (stdout);
+	  if (get_tty_line () < 0)
+		return ERR;
+	}
+    }
+  return 0;
+}
+
+
+line_t yank_buffer_head;			/* head of yank buffer */
+
+/* yank_lines: copy a range of lines to the cut buffer */
+int
+yank_lines (from, to)
+     long from;
+     long to;
+{
+  line_t *bp, *cp, *ep, *lp;
+
+
+  delete_yank_lines ();
+  ep = get_addressed_line_node (INC_MOD (to, addr_last));
+  bp = get_addressed_line_node (from);
+  for (lp = &yank_buffer_head; bp != ep; bp = bp->q_forw, lp = cp)
+    {
+      SPL1 ();
+      if ((cp = dup_line_node (bp)) == NULL)
+	{
+	  SPL0 ();
+	  return ERR;
+ 	}
+      INSQUE (cp, lp);
+      SPL0 ();
+    }
+  return 0;
+}
+
+
+/* delete_yank_lines: delete lines from the yank buffer */
+void
+delete_yank_lines ()
+{
+  line_t *cp, *lp;
+
+
+  for (lp = yank_buffer_head.q_forw; lp != &yank_buffer_head; lp = cp)
+    {
+      SPL1 ();
+      cp = lp->q_forw;
+      REQUE (lp->q_back, lp->q_forw);
+      free (lp);
+      SPL0 ();
+    }
+}
+
+
+/* put_lines: append lines from the yank buffer */
+int
+put_lines (addr)
+      long addr;
+{
+  undo_t *up = NULL;
+  line_t *lp, *cp;
+
+  if ((lp = yank_buffer_head.q_forw) == &yank_buffer_head)
+    {
+      sprintf (errmsg, "Nothing to put");
+      return ERR;
+    }
+  current_addr = addr;
+  for (; lp != &yank_buffer_head; lp = lp->q_forw)
+    {
+      SPL1 ();
+        if ((cp = dup_line_node (lp)) == NULL)
+        {
+          SPL0 ();
+          return ERR;
+        }
+      add_line_node (cp);
+      if (up)
+        up->t = cp;
+      else if ((up = push_undo_stack (UADD, current_addr,
+      				current_addr)) == NULL)
+        {
+          SPL0 ();
+          return ERR;
+        }
+      modified = 1;
+      SPL0 ();
+    }
+  return 0;
+}
+
+
+#define MAXMARK 26		/* max number of marks */
+
+line_t *mark[MAXMARK];		/* line markers */
+int markno;			/* line marker count */
+
+/* mark_line_node: set a line node mark */
+int
+mark_line_node (lp, n)
+     line_t *lp;
+     int n;
+{
+  if (!islower (n))
+    {
+      sprintf (errmsg, "Invalid mark character");
+      return ERR;
+    }
+  else if (mark[n - 'a'] == NULL)
+    markno++;
+  mark[n - 'a'] = lp;
+  return 0;
+}
+
+
+/* get_marked_node_addr: return address of a marked line */
+long
+get_marked_node_addr (n)
+     int n;
+{
+  if (!islower (n))
+    {
+      sprintf (errmsg, "Invalid mark character");
+      return ERR;
+    }
+  return get_line_node_addr (mark[n - 'a']);
+}
+
+
+/* unmark_line_node: clear line node mark */
+void
+unmark_line_node (lp)
+     line_t *lp;
+{
+  int i;
+
+  for (i = 0; markno && i < MAXMARK; i++)
+    if (mark[i] == lp)
+      {
+	mark[i] = NULL;
+	markno--;
+      }
+}
+
+
+/* dup_line_node: return a pointer to a copy of a line node */
+line_t *
+dup_line_node (lp)
+     line_t *lp;
+{
+  line_t *np;
+
+  if ((np = (line_t *) malloc (sizeof (line_t))) == NULL)
+    {
+      fprintf (stderr, "%s\n", strerror (errno));
+      sprintf (errmsg, "Out of memory");
+      return NULL;
+    }
+  np->seek = lp->seek;
+  np->len = lp->len;
+  return np;
+}
+
+
+/* has_trailing_escape:  return the parity of escapes preceding a character
+   in a string */
+int
+has_trailing_escape (s, t)
+     char *s;
+     char *t;
+{
+  return (s == t || *(t - 1) != '\\') ? 0 : !has_trailing_escape (s, t - 1);
+}
+
+
+/* strip_escapes: return copy of escaped string of at most length PATH_MAX */
+char *
+strip_escapes (s)
+     char *s;
+{
+  static char *file = NULL;
+  static int filesz = 0;
+
+  int i = 0;
+
+  REALLOC (file, filesz, PATH_MAX + 1, NULL);
+  /* assert: no trailing escape */
+  while ((file[i++] = (*s == '\\') ? *++s : *s))
+    s++;
+  return file;
+}
+
+
+#ifndef S_ISREG
+#define S_ISREG(m) ((m & S_IFMT) == S_IFREG)
+#endif
+
+/* is_regular_file: if file descriptor of a regular file, then return true;
+   otherwise return false */
+int
+is_regular_file (fd)
+  int fd;
+{
+  struct stat sb;
+
+  return fstat (fd, &sb) < 0 || S_ISREG (sb.st_mode);
+}
+
+
+/* is_legal_filename: return a legal filename */
+int
+is_legal_filename (s)
+  char *s;
+{
+  if (red && (*s == '!' || !strcmp (s, "..") || strchr (s, '/')))
+    {
+      sprintf (errmsg, "Shell access restricted");
+      return 0;
+    }
+  return 1;
+}
+
+FILE *sfp;			/* scratch file pointer */
+off_t sfseek;			/* scratch file position */
+int seek_write;			/* seek before writing */
+line_t buffer_head;		/* incore buffer */
+
+/* get_sbuf_line: get a line of text from the scratch file; return pointer
+   to the text */
+char *
+get_sbuf_line (lp)
+     line_t *lp;
+{
+  static char *sfbuf = NULL;	/* buffer */
+  static int sfbufsz = 0;	/* buffer size */
+
+  int len, ct;
+
+  if (lp == &buffer_head)
+    return NULL;
+  seek_write = 1;		/* force seek on write */
+  /* out of position */
+  if (sfseek != lp->seek)
+    {
+      sfseek = lp->seek;
+      if (fseek (sfp, sfseek, SEEK_SET) < 0)
+	{
+	  fprintf (stderr, "%s\n", strerror (errno));
+	  sprintf (errmsg, "Cannot seek temp file");
+	  return NULL;
+	}
+    }
+  len = lp->len;
+  REALLOC (sfbuf, sfbufsz, len + 1, NULL);
+  if ((ct = fread (sfbuf, sizeof (char), len, sfp)) < 0 || ct != len)
+    {
+      fprintf (stderr, "%s\n", strerror (errno));
+      sprintf (errmsg, "Cannot read temp file");
+      return NULL;
+    }
+  sfseek += len;		/* update file position */
+  sfbuf[len] = '\0';
+  return sfbuf;
+}
+
+
+/* put_sbuf_line: write a line of text to the scratch file and add a line node
+   to the editor buffer;  return a pointer to the end of the text */
+char *
+put_sbuf_line (cs)
+     char *cs;
+{
+  line_t *lp;
+  int len, ct;
+  char *s;
+
+  if ((lp = (line_t *) malloc (sizeof (line_t))) == NULL)
+    {
+      fprintf (stderr, "%s\n", strerror (errno));
+      sprintf (errmsg, "Out of memory");
+      return NULL;
+    }
+  /* assert: cs is '\n' terminated */
+  for (s = cs; *s != '\n'; s++)
+    ;
+  if (s - cs >= LINECHARS)
+    {
+      sprintf (errmsg, "Line too long");
+      return NULL;
+    }
+  len = s - cs;
+  /* out of position */
+  if (seek_write)
+    {
+      if (fseek (sfp, 0L, SEEK_END) < 0)
+	{
+	  fprintf (stderr, "%s\n", strerror (errno));
+	  sprintf (errmsg, "Cannot seek temp file");
+	  return NULL;
+	}
+      sfseek = ftell (sfp);
+      seek_write = 0;
+    }
+  /* assert: SPL1() */
+  if ((ct = fwrite (cs, sizeof (char), len, sfp)) < 0 || ct != len)
+    {
+      sfseek = -1;
+      fprintf (stderr, "%s\n", strerror (errno));
+      sprintf (errmsg, "Cannot write temp file");
+      return NULL;
+    }
+  lp->len = len;
+  lp->seek = sfseek;
+  add_line_node (lp);
+  sfseek += len;		/* update file position */
+  return ++s;
+}
+
+
+/* add_line_node: add a line node in the editor buffer after the current line */
+void
+add_line_node (lp)
+     line_t *lp;
+{
+  line_t *cp;
+
+  cp = get_addressed_line_node (current_addr);	/* this get_addressed_line_node last! */
+  INSQUE (lp, cp);
+  addr_last++;
+  current_addr++;
+}
+
+
+/* get_line_node_addr: return line number of pointer */
+long
+get_line_node_addr (lp)
+     line_t *lp;
+{
+  line_t *cp = &buffer_head;
+  long n = 0;
+
+  while (cp != lp && (cp = cp->q_forw) != &buffer_head)
+    n++;
+  if (n && cp == &buffer_head)
+    {
+      sprintf (errmsg, "Invalid address");
+      return ERR;
+    }
+  return n;
+}
+
+
+/* get_addressed_line_node: return pointer to a line node in the editor buffer */
+line_t *
+get_addressed_line_node (n)
+     long n;
+{
+  static line_t *lp = &buffer_head;
+  static long on = 0;
+
+  SPL1 ();
+  if (n > on)
+    if (n <= (on + addr_last) >> 1)
+      for (; on < n; on++)
+	lp = lp->q_forw;
+    else
+      {
+	lp = buffer_head.q_back;
+	for (on = addr_last; on > n; on--)
+	  lp = lp->q_back;
+      }
+  else if (n >= on >> 1)
+    for (; on > n; on--)
+      lp = lp->q_back;
+  else
+    {
+      lp = &buffer_head;
+      for (on = 0; on < n; on++)
+	lp = lp->q_forw;
+    }
+  SPL0 ();
+  return lp;
+}
+
+
+extern int newline_added;
+
+/* open_sbuf: open scratch file */
+int
+open_sbuf ()
+{
+  char *mktemp ();
+  int u;
+
+  isbinary = newline_added = 0;
+  u = umask(077);
+  if ((sfp = tmpfile()) == NULL)
+    {
+      fprintf (stderr, "open_sbuf: tmpfile() failed with '%s'\n", strerror (errno));
+      sprintf (errmsg, "Cannot open temp file");
+      umask(u);
+      return ERR;
+    }
+  umask(u);
+  return 0;
+}
+
+
+/* close_sbuf: close scratch file */
+int
+close_sbuf ()
+{
+  if (sfp)
+    {
+      if (fclose (sfp) < 0)
+	{
+	  fprintf (stderr, "close_sbuf: fclose on temporary file failed with '%s'.\n", strerror (errno));
+	  sprintf (errmsg, "Cannot close temp file");
+	  return ERR;
+	}
+      sfp = NULL;
+    }
+  sfseek = seek_write = 0;
+
+  return 0;
+}
+
+
+/* quit: remove_lines scratch file and exit */
+void
+quit (n)
+     int n;
+{
+  if (sfp)
+    {
+      fclose (sfp);
+    }
+  exit (n);
+}
+
+
+extern line_t yank_buffer_head;
+extern char *old_filename;
+unsigned char ctab[256];	/* character translation table */
+
+/* init_buffers: open scratch buffer; initialize line queue */
+void
+init_buffers ()
+{
+  int i = 0;
+
+  /* Read stdin one character at a time to avoid i/o contention
+     with shell escapes invoked by nonterminal input, e.g.,
+     ed - <<EOF
+     !cat
+     hello, world
+     EOF */
+#ifdef HAVE_SETBUFFER
+  setbuffer (stdin, stdinbuf, 1);
+#else
+  setvbuf (stdin, stdinbuf, _IONBF, 0);
+#endif
+  if ((errmsg = (char *) malloc (ERRSZ)) == NULL ||
+      (old_filename = (char *) malloc (PATH_MAX + 1)) == NULL)
+    {
+      fprintf (stderr, "%s\n", strerror (errno));
+      quit (2);
+    }
+  old_filename[0] = '\0';
+  if (open_sbuf () < 0)
+    quit (2);
+  REQUE (&buffer_head, &buffer_head);
+  REQUE (&yank_buffer_head, &yank_buffer_head);
+  for (i = 0; i < 256; i++)
+    ctab[i] = i;
+
+}
+
+
+/* translit_text: translate characters in a string */
+char *
+translit_text (s, len, from, to)
+     char *s;
+     int len;
+     int from;
+     int to;
+{
+  static int i = 0;
+
+  unsigned char *us;
+
+  ctab[i] = i;			/* restore table to initial state */
+  ctab[i = from] = to;
+  for (us = (unsigned char *) s; len-- > 0; us++)
+    *us = ctab[*us];
+  return s;
+}
+
+
+#ifndef SIG_ERR
+# define SIG_ERR ((void (*)()) -1)
+#endif /* !SIG_ERR */
+
+void
+(*reliable_signal (sno, hndlr)) ()
+     int sno;
+     void (*hndlr) ();
+{
+#ifndef HAVE_SIGACTION
+  signal (sno, hndlr);
+#else
+  struct sigaction sa, osa;
+
+  sa.sa_handler = hndlr;
+  sigemptyset (&sa.sa_mask);
+  sa.sa_flags = 0;
+#ifdef SA_RESTART
+      sa.sa_flags |= SA_RESTART;
+#endif
+  return (sigaction (sno, &sa, &osa) < 0) ?  SIG_ERR : osa.sa_handler;
+#endif /* HAVE_SIGACTION */
+}
+
+
+void
+signal_hup (signo)
+     int signo;
+{
+  if (mutex)
+    sigflags |= (1 << (signo - 1));
+  else
+    handle_hup (signo);
+}
+
+
+void
+signal_int (signo)
+     int signo;
+{
+  if (mutex)
+    sigflags |= (1 << (signo - 1));
+  else
+    handle_int (signo);
+}
+
+
+#ifdef HAVE_SIGSETJMP
+extern sigjmp_buf env;
+#else
+extern jmp_buf env;
+#endif
+extern int sigactive;
+
+void
+handle_hup (signo)
+     int signo;
+{
+  char *hup = NULL;		/* hup filename */
+  char *s;
+  int n;
+
+  if (!sigactive)
+    quit (1);
+  sigflags &= ~(1 << (signo - 1));
+  if (addr_last && write_file ("ed.hup", "w", 1, addr_last) < 0 &&
+      (s = getenv ("HOME")) != NULL &&
+      (n = strlen (s)) + 7 <= PATH_MAX &&	/* "ed.hup" + '/' */
+      (hup = (char *) malloc (n + 8)) != NULL)
+    {
+      strcpy (hup, s);
+      if (n && hup[n - 1] != '/')
+	  hup[n++] = '/';
+      strcpy (hup + n, "ed.hup");
+      write_file (hup, "w", 1, addr_last);
+    }
+  quit (2);
+}
+
+
+void
+handle_int (signo)
+     int signo;
+{
+  if (!sigactive)
+    quit (1);
+  sigflags &= ~(1 << (signo - 1));
+#ifdef HAVE_SIGSETJMP
+  siglongjmp (env, -1);
+#else
+  longjmp (env, -1);
+#endif
+}
+
+
+extern long rows;
+int cols = 72;			/* wrap column */
+
+void
+handle_winch (signo)
+     int signo;
+{
+#ifdef TIOCGWINSZ
+  struct winsize ws;		/* window size structure */
+#endif
+
+  sigflags &= ~(1 << (signo - 1));
+#ifdef TIOCGWINSZ
+  if (ioctl (0, TIOCGWINSZ, (char *) &ws) >= 0)
+    {
+      if (ws.ws_row > 2)
+	rows = ws.ws_row - 2;
+      if (ws.ws_col > 8)
+	cols = ws.ws_col - 8;
+    }
+#endif
+}
+
+/* read_file: read a named file/pipe into the buffer; return line count */
+long
+read_file (fn, n)
+     char *fn;
+     long n;
+{
+  FILE *fp;
+  long size;
+
+
+  fp = (*fn == '!') ? popen (fn + 1, "r") : fopen (strip_escapes (fn), "r");
+  if (fp == NULL)
+    {
+      fprintf (stderr, "%s: %s\n", fn, strerror (errno));
+      sprintf (errmsg, "Cannot open input file");
+      return ERR;
+    }
+  else if ((size = read_stream (fp, n)) < 0)
+    return ERR;
+  else if (((*fn == '!') ? pclose (fp) : fclose (fp)) < 0)
+    {
+      fprintf (stderr, "%s: %s\n", fn, strerror (errno));
+      sprintf (errmsg, "Cannot close input file");
+      return ERR;
+    }
+  fprintf (stderr, !scripted ? "%lu\n" : "", size);
+  return current_addr - n;
+}
+
+
+char *sbuf;			/* file i/o buffer */
+int sbufsz;			/* file i/o buffer size */
+int newline_added;		/* if set, newline appended to input file */
+
+/* read_stream: read a stream into the editor buffer; return status */
+long
+read_stream (fp, n)
+     FILE *fp;
+     long n;
+{
+  line_t *lp = get_addressed_line_node (n);
+  undo_t *up = NULL;
+  unsigned long size = 0;
+  int o_newline_added = newline_added;
+  int o_isbinary = isbinary;
+  int o_n = n;
+  int appended = n == addr_last;
+  int len;
+
+  isbinary = newline_added = 0;
+  for (current_addr = n; (len = get_stream_line (fp)) > 0; size += len)
+    {
+      SPL1 ();
+      if (put_sbuf_line (sbuf) == NULL)
+	{
+	  SPL0 ();
+	  return ERR;
+	}
+      lp = lp->q_forw;
+      if (up)
+	up->t = lp;
+      else if ((up = push_undo_stack (UADD, current_addr,
+				      current_addr)) == NULL)
+	{
+	  SPL0 ();
+	  return ERR;
+	}
+      SPL0 ();
+    }
+  if (len < 0)
+    return ERR;
+  if (o_n && appended && size && o_isbinary && o_newline_added)
+    fputs ("Newline inserted\n", stderr);
+  else if (newline_added && (!appended || (!isbinary && !o_isbinary)))
+    fputs ("Newline appended\n", stderr);
+  if (isbinary && newline_added && !appended)
+    size += 1;
+  if (!size)
+    newline_added = 1;
+  newline_added = appended ? newline_added : o_newline_added;
+  isbinary = isbinary | o_isbinary;
+  return size;
+}
+
+
+/* get_stream_line: read a line of text from a stream; return line length */
+int
+get_stream_line (fp)
+     FILE *fp;
+{
+  register int c;
+  register int i = 0;
+
+  while (((c = getc (fp)) != EOF || (!feof (fp) &&
+	  !ferror (fp))) && c != '\n')
+    {
+      REALLOC (sbuf, sbufsz, i + 1, ERR);
+      if (!(sbuf[i++] = c))
+	isbinary = 1;
+    }
+  REALLOC (sbuf, sbufsz, i + 2, ERR);
+  if (c == '\n')
+    sbuf[i++] = c;
+  else if (ferror (fp))
+    {
+      fprintf (stderr, "%s\n", strerror (errno));
+      sprintf (errmsg, "Cannot read input file");
+      return ERR;
+    }
+  else if (i)
+    {
+      sbuf[i++] = '\n';
+      newline_added = 1;
+    }
+  sbuf[i] = '\0';
+  return (isbinary && newline_added && i) ? --i : i;
+}
+
+
+/* write_file: write a range of lines to a named file/pipe; return line count */
+long
+write_file (fn, mode, n, m)
+     char *fn;
+     char *mode;
+     long n;
+     long m;
+{
+  FILE *fp;
+  long size;
+
+  fp = (*fn == '!') ? popen (fn + 1, "w") : fopen (strip_escapes (fn), mode);
+  if (fp == NULL)
+    {
+      fprintf (stderr, "%s: %s\n", fn, strerror (errno));
+      sprintf (errmsg, "Cannot open output file");
+      return ERR;
+    }
+  else if ((size = write_stream (fp, n, m)) < 0)
+    return ERR;
+  else if (((*fn == '!') ? pclose (fp) : fclose (fp)) < 0)
+    {
+      fprintf (stderr, "%s: %s\n", fn, strerror (errno));
+      sprintf (errmsg, "Cannot close output file");
+      return ERR;
+    }
+  fprintf (stderr, !scripted ? "%lu\n" : "", size);
+  return n ? m - n + 1 : 0;
+}
+
+
+/* write_stream: write a range of lines to a stream; return status */
+long
+write_stream (fp, n, m)
+     FILE *fp;
+     long n;
+     long m;
+{
+  line_t *lp = get_addressed_line_node (n);
+  unsigned long size = 0;
+  char *s;
+  int len;
+
+  for (; n && n <= m; n++, lp = lp->q_forw)
+    {
+      if ((s = get_sbuf_line (lp)) == NULL)
+	return ERR;
+      len = lp->len;
+      if (n != addr_last || !isbinary || !newline_added)
+	s[len++] = '\n';
+      if (put_stream_line (fp, s, len) < 0)
+	return ERR;
+      size += len;
+    }
+  return size;
+}
+
+
+/* put_stream_line: write a line of text to a stream; return status */
+int
+put_stream_line (fp, s, len)
+     FILE *fp;
+     char *s;
+     int len;
+{
+  while (len--)
+    if (fputc (*s++, fp) < 0)
+      {
+	fprintf (stderr, "%s\n", strerror (errno));
+	sprintf (errmsg, "Cannot write file");
+	return ERR;
+      }
+  return 0;
+}
+
+/* get_extended_line: get an extended line from stdin */
+char *
+get_extended_line (sizep, nonl)
+     int *sizep;
+     int nonl;
+{
+  static char *cvbuf = NULL;	/* buffer */
+  static int cvbufsz = 0;	/* buffer size */
+
+  int l, n;
+  char *t = ibufp;
+
+  while (*t++ != '\n')
+    ;
+  if ((l = t - ibufp) < 2 || !has_trailing_escape (ibufp, ibufp + l - 1))
+    {
+      *sizep = l;
+      return ibufp;
+    }
+  *sizep = -1;
+  REALLOC (cvbuf, cvbufsz, l, NULL);
+  memcpy (cvbuf, ibufp, l);
+  *(cvbuf + --l - 1) = '\n';	/* strip trailing esc */
+  if (nonl)
+    l--;			/* strip newline */
+  for (;;)
+    {
+      if ((n = get_tty_line ()) < 0)
+	return NULL;
+      else if (n == 0 || ibuf[n - 1] != '\n')
+	{
+	  sprintf (errmsg, "Unexpected end-of-file");
+	  return NULL;
+	}
+      REALLOC (cvbuf, cvbufsz, l + n, NULL);
+      memcpy (cvbuf + l, ibuf, n);
+      l += n;
+      if (n < 2 || !has_trailing_escape (cvbuf, cvbuf + l - 1))
+	break;
+      *(cvbuf + --l - 1) = '\n';	/* strip trailing esc */
+      if (nonl)
+	l--;			/* strip newline */
+    }
+  REALLOC (cvbuf, cvbufsz, l + 1, NULL);
+  cvbuf[l] = '\0';
+  *sizep = l;
+  return cvbuf;
+}
+
+
+/* get_tty_line: read a line of text from stdin; return line length */
+int
+get_tty_line ()
+{
+  register int oi = 0;
+  register int i = 0;
+  int c;
+
+  /* Read stdin one character at a time to avoid i/o contention
+     with shell escapes invoked by nonterminal input, e.g.,
+     ed - <<EOF
+     !cat
+     hello, world
+     EOF */
+  for (;;)
+    switch (c = getchar ())
+      {
+      default:
+	oi = 0;
+	REALLOC (ibuf, ibufsz, i + 2, ERR);
+	if (!(ibuf[i++] = c))
+	  isbinary = 1;
+	if (c != '\n')
+	  continue;
+	lineno++;
+	ibuf[i] = '\0';
+	ibufp = ibuf;
+	return i;
+      case EOF:
+	if (ferror (stdin))
+	  {
+	    fprintf (stderr, "stdin: %s\n", strerror (errno));
+	    sprintf (errmsg, "Cannot read stdin");
+	    clearerr (stdin);
+	    ibufp = NULL;
+	    return ERR;
+	  }
+	else
+	  {
+	    clearerr (stdin);
+	    if (i != oi)
+	      {
+		oi = i;
+		continue;
+	      }
+	    else if (i)
+	      ibuf[i] = '\0';
+	    ibufp = ibuf;
+	    return i;
+	  }
+      }
+}
+
+
+
+#define ESCAPES "\a\b\f\n\r\t\v\\"
+#define ESCCHARS "abfnrtv\\"
+
+extern long rows;
+extern int cols;
+extern int dlcnt;
+
+/* put_tty_line: print text to stdout */
+int
+put_tty_line (s, l, n, gflag)
+     char *s;
+     int l;
+     long n;
+     int gflag;
+{
+  int col = 0;
+  char *cp;
+
+  if (gflag & GNP)
+    {
+      printf ("%ld\t", n);
+      col = 8;
+    }
+  for (; l--; s++)
+    {
+      if ((gflag & GLS) && ++col > cols)
+	{
+	  fputs ("\\\n", stdout);
+	  col = 1;
+          if (!traditional && !scripted && !isglobal && ++dlcnt > rows)
+	    {
+	      dlcnt = 0;
+	      fputs ("Press <RETURN> to continue... ", stdout);
+	      fflush (stdout);
+	      if (get_tty_line () < 0)
+	        return ERR;
+	    }
+	}
+      if (gflag & GLS)
+	{
+	  if (31 < *s && *s < 127 && *s != '\\')
+	    putchar (*s);
+	  else
+	    {
+	      putchar ('\\');
+	      col++;
+	      if (*s && (cp = strchr (ESCAPES, *s)) != NULL)
+		putchar (ESCCHARS[cp - ESCAPES]);
+	      else
+		{
+		  putchar ((((unsigned char) *s & 0300) >> 6) + '0');
+		  putchar ((((unsigned char) *s & 070) >> 3) + '0');
+		  putchar (((unsigned char) *s & 07) + '0');
+		  col += 2;
+		}
+	    }
+
+	}
+      else
+	putchar (*s);
+    }
+  if (!traditional && (gflag & GLS))
+    putchar ('$');
+  putchar ('\n');
+  return 0;
+}
+
+
+
+
+char *rhbuf;			/* rhs substitution buffer */
+int rhbufsz;			/* rhs substitution buffer size */
+int rhbufi;			/* rhs substitution buffer index */
+
+/* extract_subst_tail: extract substitution tail from the command buffer */
+int
+extract_subst_tail (flagp, np)
+     int *flagp;
+     int *np;
+{
+  char delimiter;
+
+  *flagp = *np = 0;
+  if ((delimiter = *ibufp) == '\n')
+    {
+      rhbufi = 0;
+      *flagp = GPR;
+      return 0;
+    }
+  else if (extract_subst_template () == NULL)
+    return ERR;
+  else if (*ibufp == '\n')
+    {
+      *flagp = GPR;
+      return 0;
+    }
+  else if (*ibufp == delimiter)
+    ibufp++;
+  if ('1' <= *ibufp && *ibufp <= '9')
+    {
+      STRTOL (*np, ibufp);
+      return 0;
+    }
+  else if (*ibufp == 'g')
+    {
+      ibufp++;
+      *flagp = GSG;
+      return 0;
+    }
+  return 0;
+}
+
+
+/* extract_subst_template: return pointer to copy of substitution template
+   in the command buffer */
+char *
+extract_subst_template ()
+{
+  int n = 0;
+  int i = 0;
+  char c;
+  char delimiter = *ibufp++;
+
+  if (*ibufp == '%' && *(ibufp + 1) == delimiter)
+    {
+      ibufp++;
+      if (!rhbuf)
+	sprintf (errmsg, "No previous substitution");
+      return rhbuf;
+    }
+  while (*ibufp != delimiter)
+    {
+      REALLOC (rhbuf, rhbufsz, i + 2, NULL);
+      if ((c = rhbuf[i++] = *ibufp++) == '\n' && *ibufp == '\0')
+	{
+	  i--, ibufp--;
+	  break;
+	}
+      else if (c != '\\')
+	;
+      else if ((rhbuf[i++] = *ibufp++) != '\n')
+	;
+      else if (!isglobal)
+	{
+	  while ((n = get_tty_line ()) == 0 ||
+		 (n > 0 && ibuf[n - 1] != '\n'))
+	    clearerr (stdin);
+	  if (n < 0)
+	    return NULL;
+	}
+    }
+  REALLOC (rhbuf, rhbufsz, i + 1, NULL);
+  rhbuf[rhbufi = i] = '\0';
+  return rhbuf;
+}
+
+
+char *rbuf;			/* substitute_matching_text buffer */
+int rbufsz;			/* substitute_matching_text buffer size */
+
+/* search_and_replace: for each line in a range, change text matching a pattern
+   according to a substitution template; return status  */
+int
+search_and_replace (pat, gflag, kth)
+     pattern_t *pat;
+     int gflag;
+     int kth;
+{
+  undo_t *up;
+  char *txt;
+  char *eot;
+  long lc;
+  int nsubs = 0;
+  line_t *lp;
+  int len;
+
+  current_addr = first_addr - 1;
+  for (lc = 0; lc <= second_addr - first_addr; lc++)
+    {
+      lp = get_addressed_line_node (++current_addr);
+      if ((len = substitute_matching_text (pat, lp, gflag, kth)) < 0)
+	return ERR;
+      else if (len)
+	{
+	  up = NULL;
+	  if (delete_lines (current_addr, current_addr) < 0)
+	    return ERR;
+	  txt = rbuf;
+	  eot = rbuf + len;
+	  SPL1 ();
+	  do
+	    {
+	      if ((txt = put_sbuf_line (txt)) == NULL)
+		{
+		  SPL0 ();
+		  return ERR;
+		}
+	      else if (up)
+		up->t = get_addressed_line_node (current_addr);
+	      else if ((up = push_undo_stack (UADD,
+				       current_addr, current_addr)) == NULL)
+		{
+		  SPL0 ();
+		  return ERR;
+		}
+	    }
+	  while (txt != eot);
+	  SPL0 ();
+	  nsubs++;
+	}
+    }
+  if (nsubs == 0 && !(gflag & GLB))
+    {
+      sprintf (errmsg, "No match");
+      return ERR;
+    }
+  else if ((gflag & (GPR | GLS | GNP)) &&
+	   display_lines (current_addr, current_addr, gflag) < 0)
+    return ERR;
+  return 0;
+}
+
+
+/* substitute_matching_text: replace text matched by a pattern according to
+   a substitution template; return pointer to the modified text */
+int
+substitute_matching_text (pat, lp, gflag, kth)
+     pattern_t *pat;
+     line_t *lp;
+     int gflag;
+     int kth;
+{
+  int off = 0;
+  int changed = 0;
+  int matchno = 0;
+  int i = 0;
+  regmatch_t rm[SE_MAX];
+  char *txt;
+  char *eot;
+
+  if ((txt = get_sbuf_line (lp)) == NULL)
+    return ERR;
+  if (isbinary)
+    NUL_TO_NEWLINE (txt, lp->len);
+  eot = txt + lp->len;
+  if (!regexec (pat, txt, SE_MAX, rm, 0))
+    {
+      do
+	{
+	  if (!kth || kth == ++matchno)
+	    {
+	      changed++;
+	      i = rm[0].rm_so;
+	      REALLOC (rbuf, rbufsz, off + i, ERR);
+	      if (isbinary)
+		NEWLINE_TO_NUL (txt, rm[0].rm_eo);
+	      memcpy (rbuf + off, txt, i);
+	      off += i;
+	      if ((off = apply_subst_template (txt, rm, off,
+					       pat->re_nsub)) < 0)
+		return ERR;
+	    }
+	  else
+	    {
+	      i = rm[0].rm_eo;
+	      REALLOC (rbuf, rbufsz, off + i, ERR);
+	      if (isbinary)
+		NEWLINE_TO_NUL (txt, i);
+	      memcpy (rbuf + off, txt, i);
+	      off += i;
+	    }
+	  txt += rm[0].rm_eo;
+	}
+      while (*txt && (!changed || ((gflag & GSG) && rm[0].rm_eo)) &&
+	     !regexec (pat, txt, SE_MAX, rm, REG_NOTBOL));
+      i = eot - txt;
+      REALLOC (rbuf, rbufsz, off + i + 2, ERR);
+      if (i > 0 && !rm[0].rm_eo && (gflag & GSG))
+	{
+	  sprintf (errmsg, "Infinite substitution loop");
+	  return ERR;
+	}
+      if (isbinary)
+	NEWLINE_TO_NUL (txt, i);
+      memcpy (rbuf + off, txt, i);
+      memcpy (rbuf + off + i, "\n", 2);
+    }
+  return changed ? off + i + 1 : 0;
+}
+
+
+/* apply_subst_template: modify text according to a substitution template;
+   return offset to end of modified text */
+int
+apply_subst_template (boln, rm, off, re_nsub)
+     char *boln;
+     regmatch_t *rm;
+     int off;
+     int re_nsub;
+{
+  int j = 0;
+  int k = 0;
+  int n;
+  char *sub = rhbuf;
+
+  for (; sub - rhbuf < rhbufi; sub++)
+    if (*sub == '&')
+      {
+	j = rm[0].rm_so;
+	k = rm[0].rm_eo;
+	REALLOC (rbuf, rbufsz, off + k - j, ERR);
+	while (j < k)
+	  rbuf[off++] = boln[j++];
+      }
+    else if (*sub == '\\' && '1' <= *++sub && *sub <= '9' &&
+	     (n = *sub - '0') <= re_nsub)
+      {
+	j = rm[n].rm_so;
+	k = rm[n].rm_eo;
+	REALLOC (rbuf, rbufsz, off + k - j, ERR);
+	while (j < k)
+	  rbuf[off++] = boln[j++];
+      }
+    else
+      {
+	REALLOC (rbuf, rbufsz, off + 1, ERR);
+	rbuf[off++] = *sub;
+      }
+  REALLOC (rbuf, rbufsz, off + 1, ERR);
+  rbuf[off] = '\0';
+  return off;
+}
+
+
+
+#define USIZE 100		/* undo stack size */
+undo_t *ustack = NULL;		/* undo stack */
+long usize = 0;			/* stack size variable */
+long u_p = 0;			/* undo stack pointer */
+
+/* push_undo_stack: return pointer to intialized undo node */
+undo_t *
+push_undo_stack (type, from, to)
+     int type;
+     long from;
+     long to;
+{
+  undo_t *t;
+
+  if ((t = ustack) == NULL &&
+   (t = ustack = (undo_t *) malloc ((usize = USIZE) * sizeof (undo_t))) == NULL)
+    {
+      fprintf (stderr, "%s\n", strerror (errno));
+      sprintf (errmsg, "Out of memory");
+      return NULL;
+    }
+  else if (u_p >= usize &&
+      (t = (undo_t *) realloc (ustack, (usize += USIZE) * sizeof (undo_t))) == NULL)
+    {
+      /* out of memory - release undo stack */
+      fprintf (stderr, "%s\n", strerror (errno));
+      sprintf (errmsg, "Out of memory");
+      clear_undo_stack ();
+      free (ustack);
+      ustack = NULL;
+      usize = 0;
+      return NULL;
+    }
+  ustack = t;
+  ustack[u_p].type = type;
+  ustack[u_p].t = get_addressed_line_node (to);
+  ustack[u_p].h = get_addressed_line_node (from);
+  return ustack + u_p++;
+}
+
+
+/* USWAP: swap undo nodes */
+#define USWAP(x, y) \
+  do									\
+    {									\
+      undo_t utmp;							\
+      utmp = (x), (x) = (y), (y) = utmp;				\
+    }									\
+  while (0)
+
+
+long u_current_addr = -1;	/* if >= 0, undo enabled */
+long u_addr_last = -1;		/* if >= 0, undo enabled */
+
+/* pop_undo_stack: undo last change to the editor buffer */
+int
+pop_undo_stack ()
+{
+  long n;
+  long o_current_addr = current_addr;
+  long o_addr_last = addr_last;
+
+  if (u_current_addr == -1 || u_addr_last == -1)
+    {
+      sprintf (errmsg, "Nothing to undo");
+      return ERR;
+    }
+  else if (u_p)
+    modified = 1;
+  get_addressed_line_node (0);	/* this get_addressed_line_node last! */
+  SPL1 ();
+  for (n = u_p; n-- > 0;)
+    {
+      switch (ustack[n].type)
+	{
+	case UADD:
+	  REQUE (ustack[n].h->q_back, ustack[n].t->q_forw);
+	  break;
+	case UDEL:
+	  REQUE (ustack[n].h->q_back, ustack[n].h);
+	  REQUE (ustack[n].t, ustack[n].t->q_forw);
+	  break;
+	case UMOV:
+	case VMOV:
+	  REQUE (ustack[n - 1].h, ustack[n].h->q_forw);
+	  REQUE (ustack[n].t->q_back, ustack[n - 1].t);
+	  REQUE (ustack[n].h, ustack[n].t);
+	  n--;
+	  break;
+	default:
+	  /*NOTREACHED */
+	  ;
+	}
+      ustack[n].type ^= 1;
+    }
+  /* reverse undo stack order */
+  for (n = u_p; n-- > (u_p + 1) / 2;)
+    USWAP (ustack[n], ustack[u_p - 1 - n]);
+  if (isglobal)
+    clear_active_list ();
+  current_addr = u_current_addr, u_current_addr = o_current_addr;
+  addr_last = u_addr_last, u_addr_last = o_addr_last;
+  SPL0 ();
+  return 0;
+}
+
+
+/* clear_undo_stack: clear the undo stack */
+void
+clear_undo_stack ()
+{
+  line_t *lp, *ep, *tl;
+
+  while (u_p--)
+    if (ustack[u_p].type == UDEL)
+      {
+	ep = ustack[u_p].t->q_forw;
+	for (lp = ustack[u_p].h; lp != ep; lp = tl)
+	  {
+	    unmark_line_node (lp);
+	    tl = lp->q_forw;
+	    free (lp);
+	  }
+      }
+  u_p = 0;
+  u_current_addr = current_addr;
+  u_addr_last = addr_last;
+}
+
+
+
+
+/* build_active_list:  add line matching a pattern to the global-active list */
+int
+build_active_list (isgcmd)
+     int isgcmd;
+{
+  pattern_t *pat;
+  line_t *lp;
+  long n;
+  char *s;
+  char delimiter;
+
+  if ((delimiter = *ibufp) == ' ' || delimiter == '\n')
+    {
+      sprintf (errmsg, "Invalid pattern delimiter");
+      return ERR;
+    }
+  else if ((pat = get_compiled_pattern ()) == NULL)
+    return ERR;
+  else if (*ibufp == delimiter)
+    ibufp++;
+  clear_active_list ();
+  lp = get_addressed_line_node (first_addr);
+  for (n = first_addr; n <= second_addr; n++, lp = lp->q_forw)
+    {
+      if ((s = get_sbuf_line (lp)) == NULL)
+	return ERR;
+      if (isbinary)
+	NUL_TO_NEWLINE (s, lp->len);
+      if (!regexec (pat, s, 0, NULL, 0) == isgcmd &&
+	  set_active_node (lp) < 0)
+	return ERR;
+    }
+  return 0;
+}
+
+
+/* exec_global: apply command list in the command buffer to the active
+   lines in a range; return command status */
+long
+exec_global (interact, gflag)
+     int interact;
+     int gflag;
+{
+  static char *ocmd = NULL;
+  static int ocmdsz = 0;
+
+  line_t *lp = NULL;
+  int status;
+  int n;
+  char *cmd = NULL;
+
+  if (!interact)
+    if (traditional && !strcmp (ibufp, "\n"))
+      cmd = "p\n";		/* null cmd-list == `p' */
+    else if ((cmd = get_extended_line (&n, 0)) == NULL)
+      return ERR;
+  clear_undo_stack ();
+  while ((lp = next_active_node ()) != NULL)
+    {
+      if ((current_addr = get_line_node_addr (lp)) < 0)
+	return ERR;
+      if (interact)
+	{
+	  /* print current_addr; get a command in global syntax */
+	  if (display_lines (current_addr, current_addr, gflag) < 0)
+	    return ERR;
+	  while ((n = get_tty_line ()) > 0 &&
+		 ibuf[n - 1] != '\n')
+	    clearerr (stdin);
+	  if (n < 0)
+	    return ERR;
+	  else if (n == 0)
+	    {
+	      sprintf (errmsg, "Unexpected end-of-file");
+	      return ERR;
+	    }
+	  else if (n == 1 && !strcmp (ibuf, "\n"))
+	    continue;
+	  else if (n == 2 && !strcmp (ibuf, "&\n"))
+	    {
+	      if (cmd == NULL)
+		{
+		  sprintf (errmsg, "No previous command");
+		  return ERR;
+		}
+	      else
+		cmd = ocmd;
+	    }
+	  else if ((cmd = get_extended_line (&n, 0)) == NULL)
+	    return ERR;
+	  else
+	    {
+	      REALLOC (ocmd, ocmdsz, n + 1, ERR);
+	      memcpy (ocmd, cmd, n + 1);
+	      cmd = ocmd;
+	    }
+
+	}
+      ibufp = cmd;
+      for (; *ibufp;)
+	if ((status = extract_addr_range ()) < 0 ||
+	    (status = exec_command ()) < 0 ||
+	    (status > 0 && (status = display_lines (
+				   current_addr, current_addr, status)) < 0))
+	  return status;
+    }
+  return 0;
+}
+
+
+line_t **active_list;		/* list of lines active in a global command */
+long active_last;		/* index of last active line in active_list */
+long active_size;		/* size of active_list */
+long active_ptr;		/* active_list index (non-decreasing) */
+long active_ndx;		/* active_list index (modulo active_last) */
+
+/* set_active_node: add a line node to the global-active list */
+int
+set_active_node (lp)
+     line_t *lp;
+{
+  if (active_last + 1 > active_size)
+    {
+      int ti = active_size;
+      line_t **ts;
+      SPL1 ();
+      if (active_list != NULL)
+	{
+	  if ((ts = (line_t **) realloc (active_list,
+			    (ti += MINBUFSZ) * sizeof (line_t **))) == NULL)
+	    {
+	      fprintf (stderr, "%s\n", strerror (errno));
+	      sprintf (errmsg, "Out of memory");
+	      SPL0 ();
+	      return ERR;
+	    }
+	}
+      else
+	{
+	  if ((ts = (line_t **) malloc ((ti += MINBUFSZ) *
+					sizeof (line_t **))) == NULL)
+	    {
+	      fprintf (stderr, "%s\n", strerror (errno));
+	      sprintf (errmsg, "Out of memory");
+	      SPL0 ();
+	      return ERR;
+	    }
+	}
+      active_size = ti;
+      active_list = ts;
+      SPL0 ();
+    }
+  active_list[active_last++] = lp;
+  return 0;
+}
+
+
+/* unset_active_nodes: remove a range of lines from the global-active list */
+void
+unset_active_nodes (np, mp)
+     line_t *np, *mp;
+{
+  line_t *lp;
+  long i;
+
+  for (lp = np; lp != mp; lp = lp->q_forw)
+    for (i = 0; i < active_last; i++)
+      if (active_list[active_ndx] == lp)
+	{
+	  active_list[active_ndx] = NULL;
+	  active_ndx = INC_MOD (active_ndx, active_last - 1);
+	  break;
+	}
+      else
+	active_ndx = INC_MOD (active_ndx, active_last - 1);
+}
+
+
+/* next_active_node: return the next global-active line node */
+line_t *
+next_active_node ()
+{
+  while (active_ptr < active_last && active_list[active_ptr] == NULL)
+    active_ptr++;
+  return (active_ptr < active_last) ? active_list[active_ptr++] : NULL;
+}
+
+
+/* clear_active_list: clear the global-active list */
+void
+clear_active_list ()
+{
+  SPL1 ();
+  active_size = active_last = active_ptr = active_ndx = 0;
+  if (active_list != NULL)
+  	free (active_list);
+  active_list = NULL;
+  SPL0 ();
+}
+
+
+
+/* get_compiled_pattern: return pointer to compiled pattern from command
+   buffer */
+pattern_t *
+get_compiled_pattern ()
+{
+  static pattern_t *exp = NULL;
+
+  char *exps;
+  char delimiter;
+  int n;
+
+  if ((delimiter = *ibufp) == ' ')
+    {
+      sprintf (errmsg, "Invalid pattern delimiter");
+      return NULL;
+    }
+  else if (delimiter == '\n' || *++ibufp == '\n' || *ibufp == delimiter)
+    {
+      if (!exp)
+	sprintf (errmsg, "No previous pattern");
+      return exp;
+    }
+  else if ((exps = extract_pattern (delimiter)) == NULL)
+    return NULL;
+  /* buffer alloc'd && not reserved */
+  if (exp && !patlock)
+    regfree (exp);
+  else if ((exp = (pattern_t *) malloc (sizeof (pattern_t))) == NULL)
+    {
+      fprintf (stderr, "%s\n", strerror (errno));
+      sprintf (errmsg, "Out of memory");
+      return NULL;
+    }
+  patlock = 0;
+  if ((n = regcomp (exp, exps, 0)))
+    {
+      regerror (n, exp, errmsg, ERRSZ);
+      free (exp);
+      return exp = NULL;
+    }
+  return exp;
+}
+
+
+/* extract_pattern: copy a pattern string from the command buffer; return
+   pointer to the copy */
+char *
+extract_pattern (delimiter)
+     int delimiter;
+{
+  static char *lhbuf = NULL;	/* buffer */
+  static int lhbufsz = 0;	/* buffer size */
+
+  char *nd;
+  int len;
+
+  for (nd = ibufp; *nd != delimiter && *nd != '\n'; nd++)
+    switch (*nd)
+      {
+      default:
+	break;
+      case '[':
+	if ((nd = parse_char_class (++nd)) == NULL)
+	  {
+	    sprintf (errmsg, "Unbalanced brackets ([])");
+	    return NULL;
+	  }
+	break;
+      case '\\':
+	if (*++nd == '\n')
+	  {
+	    sprintf (errmsg, "Trailing backslash (\\)");
+	    return NULL;
+	  }
+	break;
+      }
+  len = nd - ibufp;
+  REALLOC (lhbuf, lhbufsz, len + 1, NULL);
+  memcpy (lhbuf, ibufp, len);
+  lhbuf[len] = '\0';
+  ibufp = nd;
+  return (isbinary) ? NUL_TO_NEWLINE (lhbuf, len) : lhbuf;
+}
+
+
+/* parse_char_class: expand a POSIX character class */
+char *
+parse_char_class (s)
+     char *s;
+{
+  int c, d;
+
+  if (*s == '^')
+    s++;
+  if (*s == ']')
+    s++;
+  for (; *s != ']' && *s != '\n'; s++)
+    if (*s == '[' && ((d = *(s + 1)) == '.' || d == ':' || d == '='))
+      for (s++, c = *++s; *s != ']' || c != d; s++)
+	if ((c = *s) == '\n')
+	  return NULL;
+  return (*s == ']') ? s : NULL;
+}
--- /dev/null	2005-04-22 11:15:01.120978184 -0400
+++ editors/ed.h	2005-04-22 11:15:09.000000000 -0400
@@ -0,0 +1,256 @@
+/* ed.h: type and constant definitions for the ed editor. */
+/* ed line editor.
+   Copyright (C) 1993, 1994 Andrew Moore, Talke Studio
+   All Rights Reserved
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+ 	@(#)$Id: ed.h,v 1.14 1994/11/13 04:25:44 alm Exp $
+*/
+
+#include <stdio.h>
+
+#define ERR (-2)
+#define EMOD (-3)
+#define FATAL (-4)
+
+#define ERRSZ (PATH_MAX + 40)	/* size of error message buffer */
+#define MINBUFSZ 512		/* minimum buffer size: must be > 0 */
+#define SE_MAX 30		/* max subexpressions in a regular expression */
+
+#define LINECHARS INT_MAX	/* max chars per line */
+
+/* gflags */
+#define GLB 001			/* global command */
+#define GPR 002			/* print after command */
+#define GLS 004			/* list after command */
+#define GNP 010			/* enumerate after command */
+#define GSG 020			/* global substitute */
+
+typedef regex_t pattern_t;
+
+/* Line node */
+typedef struct line
+  {
+    struct line *q_forw;
+    struct line *q_back;
+    off_t seek;			/* address of line in scratch buffer */
+    int len;			/* length of line */
+  }
+line_t;
+
+
+typedef struct undo
+  {
+
+/* type of undo nodes */
+#define UADD	0
+#define UDEL 	1
+#define UMOV	2
+#define VMOV	3
+
+    int type;			/* command type */
+    line_t *h;			/* head of list */
+    line_t *t;			/* tail of list */
+  }
+undo_t;
+
+#define INC_MOD(l, k)	((l) + 1 > (k) ? 0 : (l) + 1)
+#define DEC_MOD(l, k)	((l) - 1 < 0 ? (k) : (l) - 1)
+
+/* SPL1: disable some interrupts (requires reliable signals) */
+#define SPL1()		mutex++
+
+/* SPL0: enable all interrupts; check sigflags (requires reliable signals) */
+#define SPL0() \
+  do 									\
+    {									\
+      if (--mutex == 0)							\
+	{								\
+	  if (sigflags & (1 << (SIGHUP - 1))) handle_hup (SIGHUP);	\
+	  if (sigflags & (1 << (SIGINT - 1))) handle_int (SIGINT);	\
+        }								\
+    }									\
+  while (0)
+
+/* STRTOL: convert a string to long */
+#define STRTOL(i, p) \
+  do 									\
+    {									\
+      if ((((i) = strtol ((p), &(p), 10)) == LONG_MIN 			\
+          || (i) == LONG_MAX) && errno == ERANGE)			\
+	{								\
+	  sprintf (errmsg, "Number out of range");			\
+	  (i) = 0;							\
+	  return ERR;							\
+	}								\
+    }									\
+  while (0)
+
+/* REALLOC: assure at least a minimum size for buffer b */
+#define REALLOC(b, n, i, err) \
+  do 									\
+    {									\
+      if ((i) > (n))							\
+        {								\
+          int ti = (n);							\
+          char *ts;							\
+          SPL1 ();							\
+          if ((b) != NULL)						\
+	    {								\
+	      if ((ts = (char *) realloc ((b), ti += max ((i), MINBUFSZ)))	\
+		  == NULL)						\
+		{							\
+		  fprintf (stderr, "%s\n", strerror (errno));		\
+		  sprintf (errmsg, "Out of memory");			\
+		  SPL0 ();						\
+		  return err;						\
+		}							\
+	    }								\
+          else								\
+	    {								\
+	      if ((ts = (char *) malloc (ti += max ((i), MINBUFSZ)))	\
+		  == NULL)						\
+		{							\
+		  fprintf (stderr, "%s\n", strerror (errno));		\
+		  sprintf (errmsg, "Out of memory");			\
+		  SPL0 ();						\
+		  return err;						\
+		}							\
+	    }								\
+	  (n) = ti;							\
+	  (b) = ts;							\
+	  SPL0 ();							\
+        }								\
+    }									\
+  while (0)
+
+/* REQUE: link pred before succ */
+#define REQUE(pred, succ) \
+  ((pred)->q_forw = (succ), (succ)->q_back = (pred))
+
+/* INSQUE: insert elem in circular queue after pred */
+#define INSQUE(elem, pred) \
+  do									\
+    {									\
+      REQUE ((elem), (pred)->q_forw);					\
+      REQUE ((pred), (elem));						\
+    }									\
+  while (0)
+
+/* REMQUE: remove elem from circular queue */
+#define REMQUE(elem) \
+  REQUE ((elem)->q_back, (elem)->q_forw)
+
+/* NUL_TO_NEWLINE: overwrite ASCII NULs with newlines */
+#define NUL_TO_NEWLINE(s, l)	translit_text(s, l, '\0', '\n')
+
+/* NEWLINE_TO_NUL: overwrite newlines with ASCII NULs */
+#define NEWLINE_TO_NUL(s, l)	translit_text(s, l, '\n', '\0')
+
+/* Local Function Declarations */
+void add_line_node __P ((line_t *));
+int append_lines __P ((long));
+int apply_subst_template __P ((char *, regmatch_t *, int, int));
+int build_active_list __P ((int));
+int cbc_decode __P ((char *, FILE *));
+int cbc_encode __P ((char *, int, FILE *));
+int check_addr_range __P ((long, long));
+void clear_active_list __P ((void));
+void clear_undo_stack __P ((void));
+int close_sbuf __P ((void));
+int copy_lines __P ((long));
+int delete_lines __P ((long, long));
+void delete_yank_lines __P ((void));
+int display_lines __P ((long, long, int));
+line_t *dup_line_node __P ((line_t *));
+int exec_command __P ((void));
+long exec_global __P ((int, int));
+int extract_addr_range __P ((void));
+char *extract_pattern __P ((int));
+int extract_subst_tail __P ((int *, int *));
+char *extract_subst_template __P ((void));
+int filter_lines __P ((long, long, char *));
+line_t *get_addressed_line_node __P ((long));
+pattern_t *get_compiled_pattern __P ((void));
+char *get_extended_line __P ((int *, int));
+char *get_filename __P ((void));
+int get_keyword __P ((void));
+long get_line_node_addr __P ((line_t *));
+long get_matching_node_addr __P ((pattern_t *, int));
+long get_marked_node_addr __P ((int));
+char *get_sbuf_line __P ((line_t *));
+int get_shell_command __P ((void));
+int get_stream_line __P ((FILE *));
+int get_tty_line __P ((void));
+void handle_hup __P ((int));
+void handle_int __P ((int));
+void handle_winch __P ((int));
+int has_trailing_escape __P ((char *, char *));
+int hex_to_binary __P ((int, int));
+void init_buffers __P ((void));
+int is_legal_filename __P ((char *));
+int is_regular_file __P ((int));
+int join_lines __P ((long, long));
+int mark_line_node __P ((line_t *, int));
+int move_lines __P ((long));
+line_t *next_active_node ();
+long next_addr __P ((void));
+int open_sbuf __P ((void));
+char *parse_char_class __P ((char *));
+int pop_undo_stack __P ((void));
+undo_t *push_undo_stack __P ((int, long, long));
+int put_lines __P ((long));
+char *put_sbuf_line __P ((char *));
+int put_stream_line __P ((FILE *, char *, int));
+int put_tty_line __P ((char *, int, long, int));
+void quit __P ((int));
+long read_file __P ((char *, long));
+long read_stream __P ((FILE *, long));
+void (*reliable_signal __P ((int, void (*) ()))) ();
+int search_and_replace __P ((pattern_t *, int, int));
+int set_active_node __P ((line_t *));
+void signal_hup __P ((int));
+void signal_int __P ((int));
+char *strip_escapes __P ((char *));
+int substitute_matching_text __P ((pattern_t *, line_t *, int, int));
+char *translit_text __P ((char *, int, int, int));
+void unmark_line_node __P ((line_t *));
+void unset_active_nodes __P ((line_t *, line_t *));
+long write_file __P ((char *, char *, long, long));
+long write_stream __P ((FILE *, long, long));
+int yank_lines __P ((long, long));
+
+/* global buffers */
+extern char stdinbuf[];
+extern char *errmsg;
+extern char *ibuf;
+extern char *ibufp;
+extern int ibufsz;
+
+/* global flags */
+extern int isbinary;
+extern int isglobal;
+extern int modified;
+extern int mutex;
+extern int sigflags;
+extern int traditional;
+
+/* global vars */
+extern long addr_last;
+extern long current_addr;
+extern long first_addr;
+extern int lineno;
+extern long second_addr;