patch for a very alpha busybox ed

1 files changed, 3443 insertions, 0 deletions

diff --git a/patches/ed.patch b/patches/ed.patch
new file mode 100644
index 000000000..fc261b88d
--- /dev/null
+++ b/patches/ed.patch
@@ -0,0 +1,3443 @@
+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;