diff options
Diffstat (limited to 'patches')
| -rw-r--r-- | patches/ed.patch | 4284 |
1 files changed, 1176 insertions, 3108 deletions
diff --git a/patches/ed.patch b/patches/ed.patch index fc261b88d..cc3d13853 100644 --- a/patches/ed.patch +++ b/patches/ed.patch @@ -59,3385 +59,1453 @@ Index: include/applets.h #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. -+*/ -+ +--- /dev/null 2005-04-24 01:00:01.350003056 -0400 ++++ editors/ed.c 2005-04-24 01:15:09.000000000 -0400 +@@ -0,0 +1,1447 @@ +/* -+ * 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. ++ * Copyright (c) 2002 by David I. Bell ++ * Permission is granted to use, distribute, or modify this source, ++ * provided that this copyright notice remains intact. + * ++ * The "ed" built-in command (much simplified) + */ + -+#include <errno.h> -+#include <limits.h> -+#include <signal.h> -+#include <stdlib.h> +#include <stdio.h> ++#include <stdlib.h> ++#include <unistd.h> ++#include <fcntl.h> +#include <string.h> ++#include <memory.h> ++#include <time.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[] = ++#include <sys/param.h> ++#include <malloc.h> ++//#include "sash.h" ++ ++#define USERSIZE 1024 /* max line length typed in by user */ ++#define INITBUF_SIZE 1024 /* initial buffer size */ ++ ++typedef int BOOL; ++ ++#define FALSE ((BOOL) 0) ++#define TRUE ((BOOL) 1) ++ ++#define isBlank(ch) (((ch) == ' ') || ((ch) == '\t')) ++#define isDecimal(ch) (((ch) >= '0') && ((ch) <= '9')) ++ ++#define STDOUT 1 ++ ++typedef int NUM; ++typedef int LEN; ++ ++typedef struct LINE LINE; ++ ++struct LINE +{ -+ {"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}, ++ LINE * next; ++ LINE * prev; ++ LEN len; ++ char data[1]; +}; + -+extern int optind; -+extern char *optarg; + -+/* usage: explain usage */ ++static LINE lines; ++static LINE * curLine; ++static NUM curNum; ++static NUM lastNum; ++static NUM marks[26]; ++static BOOL dirty; ++static char * fileName; ++static char searchString[USERSIZE]; ++ ++static char * bufBase; ++static char * bufPtr; ++static LEN bufUsed; ++static LEN bufSize; ++ ++ ++static void doCommands(void); ++static void subCommand(const char * cmd, NUM num1, NUM num2); ++static BOOL getNum(const char ** retcp, BOOL * retHaveNum, NUM * retNum); ++static BOOL setCurNum(NUM num); ++static BOOL initEdit(void); ++static void termEdit(void); ++static void addLines(NUM num); ++static BOOL insertLine(NUM num, const char * data, LEN len); ++static BOOL deleteLines(NUM num1, NUM num2); ++static BOOL printLines(NUM num1, NUM num2, BOOL expandFlag); ++static BOOL writeLines(const char * file, NUM num1, NUM num2); ++static BOOL readLines(const char * file, NUM num); ++static NUM searchLines(const char * str, NUM num1, NUM num2); ++static LINE * findLine(NUM num); ++ ++static LEN findString ++ (const LINE * lp, const char * str, LEN len, LEN offset); ++ + -+#if 0 +void -+usage (status) -+ int status; ++ed_main(int argc, const char ** argv) +{ -+ 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() -+ ++ if (!initEdit()) ++ return; + -+/* 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) ++ if (argc > 1) + { -+ status = ERR; -+ continue; -+ } -+ else if (n == 0) -+ { -+ if (modified && !scripted) -+ { -+ fputs ("?\n", stderr); -+ sprintf (errmsg, "Warning: file modified"); -+ if (is_regular_file (0)) ++ fileName = strdup(argv[1]); ++ ++ if (fileName == NULL) + { -+ fprintf (stderr, garrulous ? -+ "script, line %d: %s\n" : -+ "", lineno, errmsg); -+ quit (2); ++ fprintf(stderr, "No memory\n"); ++ termEdit(); ++ ++ return; + } -+ 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; ++ if (!readLines(fileName, 1)) ++ { ++ termEdit(); + -+/* 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; -+} ++ return; ++ } + ++ if (lastNum) ++ setCurNum(1); + -+#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 */ ++ dirty = FALSE; ++ } ++ ++ doCommands(); ++ ++ termEdit(); +} + + -+/* 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 () ++/* ++ * Read commands until we are told to stop. ++ */ ++static void ++doCommands(void) +{ -+ 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 ++ const char * cp; ++ char * endbuf; ++ char * newname; ++ int len; ++ NUM num1; ++ NUM num2; ++ BOOL have1; ++ BOOL have2; ++ char buf[USERSIZE]; ++ ++ while (TRUE) + { -+ 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; ++ printf(": "); ++ fflush(stdout); ++ ++ if (fgets(buf, sizeof(buf), stdin) == NULL) ++ return; ++ ++ len = strlen(buf); ++ ++ if (len == 0) ++ return; ++ ++ endbuf = &buf[len - 1]; ++ ++ if (*endbuf != '\n') ++ { ++ fprintf(stderr, "Command line too long\n"); ++ ++ do ++ { ++ len = fgetc(stdin); ++ } ++ while ((len != EOF) && (len != '\n')); ++ ++ continue; + } -+ default: -+ if (sflags) ++ ++ while ((endbuf > buf) && isBlank(endbuf[-1])) ++ endbuf--; ++ ++ *endbuf = '\0'; ++ ++ cp = buf; ++ ++ while (isBlank(*cp)) ++ cp++; ++ ++ have1 = FALSE; ++ have2 = FALSE; ++ ++ if ((curNum == 0) && (lastNum > 0)) + { -+ sprintf (errmsg, "Invalid command suffix"); -+ return ERR; ++ curNum = 1; ++ curLine = lines.next; + } -+ } -+ } -+ 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; -+} + ++ if (!getNum(&cp, &have1, &num1)) ++ continue; + -+/* 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; -+} ++ while (isBlank(*cp)) ++ cp++; + ++ if (*cp == ',') ++ { ++ cp++; + -+/* 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; -+} ++ if (!getNum(&cp, &have2, &num2)) ++ continue; + ++ if (!have1) ++ num1 = 1; + -+/* get_filename: return pointer to copy of filename in the command buffer */ -+char * -+get_filename () -+{ -+ static char *file = NULL; -+ static int filesz = 0; ++ if (!have2) ++ num2 = lastNum; + -+ int n; ++ have1 = TRUE; ++ have2 = TRUE; ++ } + -+ 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; -+} ++ if (!have1) ++ num1 = curNum; + ++ if (!have2) ++ num2 = num1; + -+/* 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 == '%'; ++ switch (*cp++) ++ { ++ case 'a': ++ addLines(num1 + 1); ++ break; ++ ++ case 'c': ++ deleteLines(num1, num2); ++ addLines(num1); ++ break; ++ ++ case 'd': ++ deleteLines(num1, num2); ++ break; ++ ++ case 'f': ++ if (*cp && !isBlank(*cp)) ++ { ++ fprintf(stderr, "Bad file command\n"); ++ break; ++ } ++ ++ while (isBlank(*cp)) ++ cp++; ++ ++ if (*cp == '\0') ++ { ++ if (fileName) ++ printf("\"%s\"\n", fileName); ++ else ++ printf("No file name\n"); ++ ++ break; ++ } ++ ++ newname = strdup(cp); ++ ++ if (newname == NULL) ++ { ++ fprintf(stderr, "No memory for file name\n"); ++ break; ++ } ++ ++ if (fileName) ++ free(fileName); ++ ++ fileName = newname; ++ break; ++ ++ case 'i': ++ addLines(num1); ++ break; ++ ++ case 'k': ++ while (isBlank(*cp)) ++ cp++; ++ ++ if ((*cp < 'a') || (*cp > 'a') || cp[1]) ++ { ++ fprintf(stderr, "Bad mark name\n"); ++ break; ++ } ++ ++ marks[*cp - 'a'] = num2; ++ break; ++ ++ case 'l': ++ printLines(num1, num2, TRUE); ++ break; ++ ++ case 'p': ++ printLines(num1, num2, FALSE); ++ break; ++ ++ case 'q': ++ while (isBlank(*cp)) ++ cp++; ++ ++ if (have1 || *cp) ++ { ++ fprintf(stderr, "Bad quit command\n"); ++ break; ++ } ++ ++ if (!dirty) ++ return; ++ ++ printf("Really quit? "); ++ fflush(stdout); ++ ++ buf[0] = '\0'; ++ fgets(buf, sizeof(buf), stdin); ++ cp = buf; ++ ++ while (isBlank(*cp)) ++ cp++; ++ ++ if ((*cp == 'y') || (*cp == 'Y')) ++ return; ++ ++ break; ++ ++ case 'r': ++ if (*cp && !isBlank(*cp)) ++ { ++ fprintf(stderr, "Bad read command\n"); ++ break; ++ } ++ ++ while (isBlank(*cp)) ++ cp++; ++ ++ if (*cp == '\0') ++ { ++ fprintf(stderr, "No file name\n"); ++ break; ++ } ++ ++ if (!have1) ++ num1 = lastNum; ++ ++ if (readLines(cp, num1 + 1)) ++ break; ++ ++ if (fileName == NULL) ++ fileName = strdup(cp); ++ ++ break; ++ ++ case 's': ++ subCommand(cp, num1, num2); ++ break; ++ ++ case 'w': ++ if (*cp && !isBlank(*cp)) ++ { ++ fprintf(stderr, "Bad write command\n"); ++ break; ++ } ++ ++ while (isBlank(*cp)) ++ cp++; ++ ++ if (!have1) { ++ num1 = 1; ++ num2 = lastNum; ++ } ++ ++ if (*cp == '\0') ++ cp = fileName; ++ ++ if (cp == NULL) ++ { ++ fprintf(stderr, "No file name specified\n"); ++ break; ++ } ++ ++ writeLines(cp, num1, num2); ++ break; ++ ++ case 'z': ++ switch (*cp) ++ { ++ case '-': ++ printLines(curNum-21, curNum, FALSE); ++ break; ++ case '.': ++ printLines(curNum-11, curNum+10, FALSE); ++ break; ++ default: ++ printLines(curNum, curNum+21, FALSE); ++ break; ++ } ++ break; ++ ++ case '.': ++ if (have1) ++ { ++ fprintf(stderr, "No arguments allowed\n"); ++ break; ++ } ++ ++ printLines(curNum, curNum, FALSE); ++ break; ++ ++ case '-': ++ if (setCurNum(curNum - 1)) ++ printLines(curNum, curNum, FALSE); ++ ++ break; ++ ++ case '=': ++ printf("%d\n", num1); ++ break; ++ ++ case '\0': ++ if (have1) ++ { ++ printLines(num2, num2, FALSE); ++ break; ++ } ++ ++ if (setCurNum(curNum + 1)) ++ printLines(curNum, curNum, FALSE); ++ ++ break; ++ ++ default: ++ fprintf(stderr, "Unimplemented command\n"); ++ break; ++ } ++ } +} + + -+/* 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; ++/* ++ * Do the substitute command. ++ * The current line is set to the last substitution done. ++ */ ++static void ++subCommand(const char * cmd, NUM num1, NUM num2) +{ -+ 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 ++ int delim; ++ char * cp; ++ char * oldStr; ++ char * newStr; ++ LEN oldLen; ++ LEN newLen; ++ LEN deltaLen; ++ LEN offset; ++ LINE * lp; ++ LINE * nlp; ++ BOOL globalFlag; ++ BOOL printFlag; ++ BOOL didSub; ++ BOOL needPrint; ++ char buf[USERSIZE]; ++ ++ if ((num1 < 1) || (num2 > lastNum) || (num1 > num2)) + { -+ while (*ibufp++ != '\n') -+ ; -+ l = ibufp - lp; ++ fprintf(stderr, "Bad line range for substitute\n"); ++ ++ return; + } -+ if (l == 2 && lp[0] == '.' && lp[1] == '\n') ++ ++ globalFlag = FALSE; ++ printFlag = FALSE; ++ didSub = FALSE; ++ needPrint = FALSE; ++ ++ /* ++ * Copy the command so we can modify it. ++ */ ++ strcpy(buf, cmd); ++ cp = buf; ++ ++ if (isBlank(*cp) || (*cp == '\0')) + { -+ return 0; ++ fprintf(stderr, "Bad delimiter for substitute\n"); ++ ++ return; + } -+ eot = lp + l; -+ SPL1 (); -+ do ++ ++ delim = *cp++; ++ oldStr = cp; ++ ++ cp = strchr(cp, delim); ++ ++ if (cp == NULL) + { -+ 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; -+ } ++ fprintf(stderr, "Missing 2nd delimiter for substitute\n"); ++ ++ return; + } -+ while (lp != eot); -+ modified = 1; -+ SPL0 (); -+ } -+ /* NOTREACHED */ -+} + ++ *cp++ = '\0'; + -+/* 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; -+} ++ newStr = cp; ++ cp = strchr(cp, delim); + ++ if (cp) ++ *cp++ = '\0'; ++ else ++ cp = ""; + -+/* 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) ++ while (*cp) switch (*cp++) + { -+ b1 = get_addressed_line_node (p); -+ b2 = get_addressed_line_node (addr); -+ /* this get_addressed_line_node last! */ ++ case 'g': ++ globalFlag = TRUE; ++ break; ++ ++ case 'p': ++ printFlag = TRUE; ++ break; ++ ++ default: ++ fprintf(stderr, "Unknown option for substitute\n"); ++ ++ return; + } -+ else ++ ++ if (*oldStr == '\0') + { -+ 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; -+} ++ if (searchString[0] == '\0') ++ { ++ fprintf(stderr, "No previous search string\n"); + ++ return; ++ } + -+/* 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; -+} ++ oldStr = searchString; ++ } + ++ if (oldStr != searchString) ++ strcpy(searchString, oldStr); + -+/* 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; -+} ++ lp = findLine(num1); + ++ if (lp == NULL) ++ return; + -+int dlcnt = 0; /* # of lines displayed */ ++ oldLen = strlen(oldStr); ++ newLen = strlen(newStr); ++ deltaLen = newLen - oldLen; ++ offset = 0; ++ nlp = NULL; + -+/* 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) ++ while (num1 <= num2) + { -+ dlcnt = 0; -+ fputs ("Press <RETURN> to continue... ", stdout); -+ fflush (stdout); -+ if (get_tty_line () < 0) -+ return ERR; -+ } -+ } -+ return 0; -+} ++ offset = findString(lp, oldStr, oldLen, offset); + ++ if (offset < 0) ++ { ++ if (needPrint) ++ { ++ printLines(num1, num1, FALSE); ++ needPrint = FALSE; ++ } + -+line_t yank_buffer_head; /* head of yank buffer */ ++ offset = 0; ++ lp = lp->next; ++ num1++; + -+/* 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; ++ continue; ++ } + ++ needPrint = printFlag; ++ didSub = TRUE; ++ dirty = TRUE; + -+ 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; -+} ++ /* ++ * If the replacement string is the same size or shorter ++ * than the old string, then the substitution is easy. ++ */ ++ if (deltaLen <= 0) ++ { ++ memcpy(&lp->data[offset], newStr, newLen); + ++ if (deltaLen) ++ { ++ memcpy(&lp->data[offset + newLen], ++ &lp->data[offset + oldLen], ++ lp->len - offset - oldLen); + -+/* delete_yank_lines: delete lines from the yank buffer */ -+void -+delete_yank_lines () -+{ -+ line_t *cp, *lp; ++ lp->len += deltaLen; ++ } + ++ offset += newLen; + -+ 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 (); -+ } -+} ++ if (globalFlag) ++ continue; + ++ if (needPrint) ++ { ++ printLines(num1, num1, FALSE); ++ needPrint = FALSE; ++ } + -+/* 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; -+} ++ lp = lp->next; ++ num1++; ++ ++ continue; ++ } + ++ /* ++ * The new string is larger, so allocate a new line ++ * structure and use that. Link it in in place of ++ * the old line structure. ++ */ ++ nlp = (LINE *) malloc(sizeof(LINE) + lp->len + deltaLen); + -+#define MAXMARK 26 /* max number of marks */ ++ if (nlp == NULL) ++ { ++ fprintf(stderr, "Cannot get memory for line\n"); + -+line_t *mark[MAXMARK]; /* line markers */ -+int markno; /* line marker count */ ++ return; ++ } + -+/* 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; -+} ++ nlp->len = lp->len + deltaLen; + ++ memcpy(nlp->data, lp->data, offset); + -+/* 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']); -+} ++ memcpy(&nlp->data[offset], newStr, newLen); + ++ memcpy(&nlp->data[offset + newLen], ++ &lp->data[offset + oldLen], ++ lp->len - offset - oldLen); + -+/* 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--; -+ } -+} ++ nlp->next = lp->next; ++ nlp->prev = lp->prev; ++ nlp->prev->next = nlp; ++ nlp->next->prev = nlp; + ++ if (curLine == lp) ++ curLine = nlp; + -+/* 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; -+} ++ free(lp); ++ lp = nlp; + ++ offset += newLen; + -+/* 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); ++ if (globalFlag) ++ continue; ++ ++ if (needPrint) ++ { ++ printLines(num1, num1, FALSE); ++ needPrint = FALSE; ++ } ++ ++ lp = lp->next; ++ num1++; ++ } ++ ++ if (!didSub) ++ fprintf(stderr, "No substitutions found for \"%s\"\n", oldStr); +} + + -+/* strip_escapes: return copy of escaped string of at most length PATH_MAX */ -+char * -+strip_escapes (s) -+ char *s; ++/* ++ * Search a line for the specified string starting at the specified ++ * offset in the line. Returns the offset of the found string, or -1. ++ */ ++static LEN ++findString( const LINE * lp, const char * str, LEN len, LEN offset) +{ -+ static char *file = NULL; -+ static int filesz = 0; ++ LEN left; ++ const char * cp; ++ const char * ncp; + -+ int i = 0; ++ cp = &lp->data[offset]; ++ left = lp->len - offset; + -+ REALLOC (file, filesz, PATH_MAX + 1, NULL); -+ /* assert: no trailing escape */ -+ while ((file[i++] = (*s == '\\') ? *++s : *s)) -+ s++; -+ return file; -+} ++ while (left >= len) ++ { ++ ncp = memchr(cp, *str, left); + ++ if (ncp == NULL) ++ return -1; + -+#ifndef S_ISREG -+#define S_ISREG(m) ((m & S_IFMT) == S_IFREG) -+#endif ++ left -= (ncp - cp); + -+/* 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; ++ if (left < len) ++ return -1; + -+ return fstat (fd, &sb) < 0 || S_ISREG (sb.st_mode); -+} ++ cp = ncp; + ++ if (memcmp(cp, str, len) == 0) ++ return (cp - lp->data); + -+/* 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; ++ cp++; ++ left--; ++ } ++ ++ 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; ++/* ++ * Add lines which are typed in by the user. ++ * The lines are inserted just before the specified line number. ++ * The lines are terminated by a line containing a single dot (ugly!), ++ * or by an end of file. ++ */ ++static void ++addLines(NUM num) +{ -+ 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) ++ int len; ++ char buf[USERSIZE + 1]; ++ ++ while (fgets(buf, sizeof(buf), stdin)) + { -+ fprintf (stderr, "%s\n", strerror (errno)); -+ sprintf (errmsg, "Cannot seek temp file"); -+ return NULL; ++ if ((buf[0] == '.') && (buf[1] == '\n') && (buf[2] == '\0')) ++ return; ++ ++ len = strlen(buf); ++ ++ if (len == 0) ++ return; ++ ++ if (buf[len - 1] != '\n') ++ { ++ fprintf(stderr, "Line too long\n"); ++ ++ do ++ { ++ len = fgetc(stdin); ++ } ++ while ((len != EOF) && (len != '\n')); ++ ++ return; ++ } ++ ++ if (!insertLine(num++, buf, len)) ++ return; + } -+ } -+ 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; ++/* ++ * Parse a line number argument if it is present. This is a sum ++ * or difference of numbers, '.', '$', 'x, or a search string. ++ * Returns TRUE if successful (whether or not there was a number). ++ * Returns FALSE if there was a parsing error, with a message output. ++ * Whether there was a number is returned indirectly, as is the number. ++ * The character pointer which stopped the scan is also returned. ++ */ ++static BOOL ++getNum(const char ** retcp, BOOL * retHaveNum, NUM * retNum) +{ -+ 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) ++ const char * cp; ++ char * endStr; ++ char str[USERSIZE]; ++ BOOL haveNum; ++ NUM value; ++ NUM num; ++ NUM sign; ++ ++ cp = *retcp; ++ haveNum = FALSE; ++ value = 0; ++ sign = 1; ++ ++ while (TRUE) + { -+ 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; -+} ++ while (isBlank(*cp)) ++ cp++; + ++ switch (*cp) ++ { ++ case '.': ++ haveNum = TRUE; ++ num = curNum; ++ cp++; ++ break; + -+/* 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; ++ case '$': ++ haveNum = TRUE; ++ num = lastNum; ++ cp++; ++ break; + -+ cp = get_addressed_line_node (current_addr); /* this get_addressed_line_node last! */ -+ INSQUE (lp, cp); -+ addr_last++; -+ current_addr++; -+} ++ case '\'': ++ cp++; + ++ if ((*cp < 'a') || (*cp > 'z')) ++ { ++ fprintf(stderr, "Bad mark name\n"); + -+/* 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; -+} ++ return FALSE; ++ } + ++ haveNum = TRUE; ++ num = marks[*cp++ - 'a']; ++ break; + -+/* 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; -+} ++ case '/': ++ strcpy(str, ++cp); ++ endStr = strchr(str, '/'); + ++ if (endStr) ++ { ++ *endStr++ = '\0'; ++ cp += (endStr - str); ++ } ++ else ++ cp = ""; + -+extern int newline_added; ++ num = searchLines(str, curNum, lastNum); + -+/* 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; -+} ++ if (num == 0) ++ return FALSE; + ++ haveNum = TRUE; ++ break; + -+/* 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; ++ default: ++ if (!isDecimal(*cp)) ++ { ++ *retcp = cp; ++ *retHaveNum = haveNum; ++ *retNum = value; + -+ return 0; -+} ++ return TRUE; ++ } + ++ num = 0; + -+/* quit: remove_lines scratch file and exit */ -+void -+quit (n) -+ int n; -+{ -+ if (sfp) -+ { -+ fclose (sfp); -+ } -+ exit (n); -+} ++ while (isDecimal(*cp)) ++ num = num * 10 + *cp++ - '0'; + ++ haveNum = TRUE; ++ break; ++ } + -+extern line_t yank_buffer_head; -+extern char *old_filename; -+unsigned char ctab[256]; /* character translation table */ ++ value += num * sign; + -+/* 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; ++ while (isBlank(*cp)) ++ cp++; + ++ switch (*cp) ++ { ++ case '-': ++ sign = -1; ++ cp++; ++ break; ++ ++ case '+': ++ sign = 1; ++ cp++; ++ break; ++ ++ default: ++ *retcp = cp; ++ *retHaveNum = haveNum; ++ *retNum = value; ++ ++ return TRUE; ++ } ++ } +} + + -+/* translit_text: translate characters in a string */ -+char * -+translit_text (s, len, from, to) -+ char *s; -+ int len; -+ int from; -+ int to; ++/* ++ * Initialize everything for editing. ++ */ ++static BOOL ++initEdit(void) +{ -+ static int i = 0; ++ int i; + -+ unsigned char *us; ++ bufSize = INITBUF_SIZE; ++ bufBase = malloc(bufSize); + -+ 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; -+} ++ if (bufBase == NULL) ++ { ++ fprintf(stderr, "No memory for buffer\n"); + ++ return FALSE; ++ } + -+#ifndef SIG_ERR -+# define SIG_ERR ((void (*)()) -1) -+#endif /* !SIG_ERR */ ++ bufPtr = bufBase; ++ bufUsed = 0; + -+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 */ -+} ++ lines.next = &lines; ++ lines.prev = &lines; + ++ curLine = NULL; ++ curNum = 0; ++ lastNum = 0; ++ dirty = FALSE; ++ fileName = NULL; ++ searchString[0] = '\0'; + -+void -+signal_hup (signo) -+ int signo; -+{ -+ if (mutex) -+ sigflags |= (1 << (signo - 1)); -+ else -+ handle_hup (signo); ++ for (i = 0; i < 26; i++) ++ marks[i] = 0; ++ ++ return TRUE; +} + + -+void -+signal_int (signo) -+ int signo; ++/* ++ * Finish editing. ++ */ ++static void ++termEdit(void) +{ -+ if (mutex) -+ sigflags |= (1 << (signo - 1)); -+ else -+ handle_int (signo); -+} ++ if (bufBase) ++ free(bufBase); + ++ bufBase = NULL; ++ bufPtr = NULL; ++ bufSize = 0; ++ bufUsed = 0; + -+#ifdef HAVE_SIGSETJMP -+extern sigjmp_buf env; -+#else -+extern jmp_buf env; -+#endif -+extern int sigactive; ++ if (fileName) ++ free(fileName); + -+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); ++ fileName = NULL; ++ ++ searchString[0] = '\0'; ++ ++ if (lastNum) ++ deleteLines(1, lastNum); ++ ++ lastNum = 0; ++ curNum = 0; ++ curLine = NULL; +} + + -+void -+handle_int (signo) -+ int signo; ++/* ++ * Read lines from a file at the specified line number. ++ * Returns TRUE if the file was successfully read. ++ */ ++static BOOL ++readLines(const char * file, NUM num) +{ -+ if (!sigactive) -+ quit (1); -+ sigflags &= ~(1 << (signo - 1)); -+#ifdef HAVE_SIGSETJMP -+ siglongjmp (env, -1); -+#else -+ longjmp (env, -1); -+#endif -+} ++ int fd; ++ int cc; ++ LEN len; ++ LEN lineCount; ++ LEN charCount; ++ char * cp; + ++ if ((num < 1) || (num > lastNum + 1)) ++ { ++ fprintf(stderr, "Bad line for read\n"); + -+extern long rows; -+int cols = 72; /* wrap column */ ++ return FALSE; ++ } + -+void -+handle_winch (signo) -+ int signo; -+{ -+#ifdef TIOCGWINSZ -+ struct winsize ws; /* window size structure */ -+#endif ++ fd = open(file, 0); + -+ 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 -+} ++ if (fd < 0) ++ { ++ perror(file); + -+/* 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; -+} ++ return FALSE; ++ } + ++ bufPtr = bufBase; ++ bufUsed = 0; ++ lineCount = 0; ++ charCount = 0; ++ cc = 0; + -+char *sbuf; /* file i/o buffer */ -+int sbufsz; /* file i/o buffer size */ -+int newline_added; /* if set, newline appended to input file */ ++ printf("\"%s\", ", file); ++ fflush(stdout); + -+/* 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) ++ do + { -+ SPL0 (); -+ return ERR; ++ cp = memchr(bufPtr, '\n', bufUsed); ++ ++ if (cp) ++ { ++ len = (cp - bufPtr) + 1; ++ ++ if (!insertLine(num, bufPtr, len)) ++ { ++ close(fd); ++ ++ return FALSE; ++ } ++ ++ bufPtr += len; ++ bufUsed -= len; ++ charCount += len; ++ lineCount++; ++ num++; ++ ++ continue; ++ } ++ ++ if (bufPtr != bufBase) ++ { ++ memcpy(bufBase, bufPtr, bufUsed); ++ bufPtr = bufBase + bufUsed; ++ } ++ ++ if (bufUsed >= bufSize) ++ { ++ len = (bufSize * 3) / 2; ++ cp = realloc(bufBase, len); ++ ++ if (cp == NULL) ++ { ++ fprintf(stderr, "No memory for buffer\n"); ++ close(fd); ++ ++ return FALSE; ++ } ++ ++ bufBase = cp; ++ bufPtr = bufBase + bufUsed; ++ bufSize = len; ++ } ++ ++ cc = read(fd, bufPtr, bufSize - bufUsed); ++ bufUsed += cc; ++ bufPtr = bufBase; ++ + } -+ lp = lp->q_forw; -+ if (up) -+ up->t = lp; -+ else if ((up = push_undo_stack (UADD, current_addr, -+ current_addr)) == NULL) ++ while (cc > 0); ++ ++ if (cc < 0) + { -+ SPL0 (); -+ return ERR; ++ perror(file); ++ close(fd); ++ ++ return FALSE; + } -+ 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; -+} + ++ if (bufUsed) ++ { ++ if (!insertLine(num, bufPtr, bufUsed)) ++ { ++ close(fd); + -+/* 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; -+} ++ return -1; ++ } + ++ lineCount++; ++ charCount += bufUsed; ++ } + -+/* 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; -+} ++ close(fd); + ++ printf("%d lines%s, %d chars\n", lineCount, ++ (bufUsed ? " (incomplete)" : ""), charCount); + -+/* 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; ++ return TRUE; +} + + -+/* 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; ++/* ++ * Write the specified lines out to the specified file. ++ * Returns TRUE if successful, or FALSE on an error with a message output. ++ */ ++static BOOL ++writeLines(const char * file, NUM num1, NUM num2) +{ -+ while (len--) -+ if (fputc (*s++, fp) < 0) -+ { -+ fprintf (stderr, "%s\n", strerror (errno)); -+ sprintf (errmsg, "Cannot write file"); -+ return ERR; -+ } -+ return 0; -+} ++ int fd; ++ LINE * lp; ++ LEN lineCount; ++ LEN charCount; + -+/* 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') ++ if ((num1 < 1) || (num2 > lastNum) || (num1 > num2)) + { -+ sprintf (errmsg, "Unexpected end-of-file"); -+ return NULL; ++ fprintf(stderr, "Bad line range for write\n"); ++ ++ return FALSE; + } -+ 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; -+} + ++ lineCount = 0; ++ charCount = 0; + -+/* 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; -+ } -+ } -+} ++ fd = creat(file, 0666); + ++ if (fd < 0) { ++ perror(file); + ++ return FALSE; ++ } + -+#define ESCAPES "\a\b\f\n\r\t\v\\" -+#define ESCCHARS "abfnrtv\\" ++ printf("\"%s\", ", file); ++ fflush(stdout); + -+extern long rows; -+extern int cols; -+extern int dlcnt; ++ lp = findLine(num1); + -+/* 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) ++ if (lp == NULL) + { -+ 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; -+ } ++ close(fd); ++ ++ return FALSE; + } -+ if (gflag & GLS) ++ ++ while (num1++ <= num2) + { -+ if (31 < *s && *s < 127 && *s != '\\') -+ putchar (*s); -+ else -+ { -+ putchar ('\\'); -+ col++; -+ if (*s && (cp = strchr (ESCAPES, *s)) != NULL) -+ putchar (ESCCHARS[cp - ESCAPES]); -+ else ++ if (write(fd, lp->data, lp->len) != lp->len) + { -+ putchar ((((unsigned char) *s & 0300) >> 6) + '0'); -+ putchar ((((unsigned char) *s & 070) >> 3) + '0'); -+ putchar (((unsigned char) *s & 07) + '0'); -+ col += 2; ++ perror(file); ++ close(fd); ++ ++ return FALSE; + } -+ } + ++ charCount += lp->len; ++ lineCount++; ++ lp = lp->next; + } -+ else -+ putchar (*s); -+ } -+ if (!traditional && (gflag & GLS)) -+ putchar ('$'); -+ putchar ('\n'); -+ return 0; -+} -+ + ++ if (close(fd) < 0) ++ { ++ perror(file); + ++ return FALSE; ++ } + -+char *rhbuf; /* rhs substitution buffer */ -+int rhbufsz; /* rhs substitution buffer size */ -+int rhbufi; /* rhs substitution buffer index */ ++ printf("%d lines, %d chars\n", lineCount, charCount); + -+/* 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; ++ return TRUE; +} + + -+/* extract_subst_template: return pointer to copy of substitution template -+ in the command buffer */ -+char * -+extract_subst_template () ++/* ++ * Print lines in a specified range. ++ * The last line printed becomes the current line. ++ * If expandFlag is TRUE, then the line is printed specially to ++ * show magic characters. ++ */ ++static BOOL ++printLines(NUM num1, NUM num2, BOOL expandFlag) +{ -+ 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) ++ const LINE * lp; ++ const unsigned char * cp; ++ int ch; ++ LEN count; ++ ++ if ((num1 < 1) || (num2 > lastNum) || (num1 > num2)) + { -+ while ((n = get_tty_line ()) == 0 || -+ (n > 0 && ibuf[n - 1] != '\n')) -+ clearerr (stdin); -+ if (n < 0) -+ return NULL; ++ fprintf(stderr, "Bad line range for print\n"); ++ ++ return FALSE; + } -+ } -+ REALLOC (rhbuf, rhbufsz, i + 1, NULL); -+ rhbuf[rhbufi = i] = '\0'; -+ return rhbuf; -+} + ++ lp = findLine(num1); + -+char *rbuf; /* substitute_matching_text buffer */ -+int rbufsz; /* substitute_matching_text buffer size */ ++ if (lp == NULL) ++ return FALSE; + -+/* 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) ++ while (num1 <= num2) + { -+ 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) ++ if (!expandFlag) + { -+ SPL0 (); -+ return ERR; ++ write(STDOUT, lp->data, lp->len); ++ setCurNum(num1++); ++ lp = lp->next; ++ ++ continue; + } -+ else if (up) -+ up->t = get_addressed_line_node (current_addr); -+ else if ((up = push_undo_stack (UADD, -+ current_addr, current_addr)) == NULL) ++ ++ /* ++ * Show control characters and characters with the ++ * high bit set specially. ++ */ ++ cp = lp->data; ++ count = lp->len; ++ ++ if ((count > 0) && (cp[count - 1] == '\n')) ++ count--; ++ ++ while (count-- > 0) + { -+ SPL0 (); -+ return ERR; ++ ch = *cp++; ++ ++ if (ch & 0x80) ++ { ++ fputs("M-", stdout); ++ ch &= 0x7f; ++ } ++ ++ if (ch < ' ') ++ { ++ fputc('^', stdout); ++ ch += '@'; ++ } ++ ++ if (ch == 0x7f) ++ { ++ fputc('^', stdout); ++ ch = '?'; ++ } ++ ++ fputc(ch, stdout); + } -+ } -+ while (txt != eot); -+ SPL0 (); -+ nsubs++; ++ ++ fputs("$\n", stdout); ++ ++ setCurNum(num1++); ++ lp = lp->next; + } -+ } -+ 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; ++ ++ return TRUE; +} + + -+/* 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; ++/* ++ * Insert a new line with the specified text. ++ * The line is inserted so as to become the specified line, ++ * thus pushing any existing and further lines down one. ++ * The inserted line is also set to become the current line. ++ * Returns TRUE if successful. ++ */ ++static BOOL ++insertLine(NUM num, const char * data, LEN len) +{ -+ 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 ++ LINE * newLp; ++ LINE * lp; ++ ++ if ((num < 1) || (num > lastNum + 1)) + { -+ 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; ++ fprintf(stderr, "Inserting at bad line number\n"); ++ ++ return FALSE; + } -+ 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)) ++ ++ newLp = (LINE *) malloc(sizeof(LINE) + len - 1); ++ ++ if (newLp == NULL) + { -+ sprintf (errmsg, "Infinite substitution loop"); -+ return ERR; ++ fprintf(stderr, "Failed to allocate memory for line\n"); ++ ++ return FALSE; + } -+ if (isbinary) -+ NEWLINE_TO_NUL (txt, i); -+ memcpy (rbuf + off, txt, i); -+ memcpy (rbuf + off + i, "\n", 2); -+ } -+ return changed ? off + i + 1 : 0; -+} + ++ memcpy(newLp->data, data, len); ++ newLp->len = len; + -+/* 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; -+} ++ if (num > lastNum) ++ lp = &lines; ++ else ++ { ++ lp = findLine(num); + ++ if (lp == NULL) ++ { ++ free((char *) newLp); + ++ return FALSE; ++ } ++ } + -+#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 */ ++ newLp->next = lp; ++ newLp->prev = lp->prev; ++ lp->prev->next = newLp; ++ lp->prev = newLp; + -+/* 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++; ++ lastNum++; ++ dirty = TRUE; ++ ++ return setCurNum(num); +} + + -+/* USWAP: swap undo nodes */ -+#define USWAP(x, y) \ -+ do \ -+ { \ -+ undo_t utmp; \ -+ utmp = (x), (x) = (y), (y) = utmp; \ -+ } \ -+ while (0) ++/* ++ * Delete lines from the given range. ++ */ ++static BOOL ++deleteLines(NUM num1, NUM num2) ++{ ++ LINE * lp; ++ LINE * nlp; ++ LINE * plp; ++ NUM count; + ++ if ((num1 < 1) || (num2 > lastNum) || (num1 > num2)) ++ { ++ fprintf(stderr, "Bad line numbers for delete\n"); + -+long u_current_addr = -1; /* if >= 0, undo enabled */ -+long u_addr_last = -1; /* if >= 0, undo enabled */ ++ return FALSE; ++ } + -+/* 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) ++ lp = findLine(num1); ++ ++ if (lp == NULL) ++ return FALSE; ++ ++ if ((curNum >= num1) && (curNum <= num2)) + { -+ 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 */ -+ ; ++ if (num2 < lastNum) ++ setCurNum(num2 + 1); ++ else if (num1 > 1) ++ setCurNum(num1 - 1); ++ else ++ curNum = 0; + } -+ 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; -+} + ++ count = num2 - num1 + 1; + -+/* 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; -+} ++ if (curNum > num2) ++ curNum -= count; + ++ lastNum -= count; + ++ while (count-- > 0) ++ { ++ nlp = lp->next; ++ plp = lp->prev; ++ plp->next = nlp; ++ nlp->prev = plp; ++ lp->next = NULL; ++ lp->prev = NULL; ++ lp->len = 0; ++ free(lp); ++ lp = nlp; ++ } + ++ dirty = TRUE; + -+/* 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; ++ return TRUE; +} + + -+/* 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; ++/* ++ * Search for a line which contains the specified string. ++ * If the string is NULL, then the previously searched for string ++ * is used. The currently searched for string is saved for future use. ++ * Returns the line number which matches, or 0 if there was no match ++ * with an error printed. ++ */ ++static NUM ++searchLines(const char * str, NUM num1, NUM num2) +{ -+ 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) ++ const LINE * lp; ++ int len; ++ ++ if ((num1 < 1) || (num2 > lastNum) || (num1 > num2)) ++ { ++ fprintf(stderr, "Bad line numbers for search\n"); ++ ++ return 0; ++ } ++ ++ if (*str == '\0') + { -+ /* 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) ++ if (searchString[0] == '\0') + { -+ sprintf (errmsg, "No previous command"); -+ return ERR; ++ fprintf(stderr, "No previous search string\n"); ++ ++ return 0; + } -+ 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; -+ } + ++ str = searchString; + } -+ 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; -+} + ++ if (str != searchString) ++ strcpy(searchString, str); + -+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) */ ++ len = strlen(str); + -+/* 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 ++ lp = findLine(num1); ++ ++ if (lp == NULL) ++ return 0; ++ ++ while (num1 <= num2) + { -+ 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; -+ } ++ if (findString(lp, str, len, 0) >= 0) ++ return num1; ++ ++ num1++; ++ lp = lp->next; + } -+ active_size = ti; -+ active_list = ts; -+ SPL0 (); -+ } -+ active_list[active_last++] = lp; -+ return 0; ++ ++ fprintf(stderr, "Cannot find string \"%s\"\n", str); ++ ++ 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; ++/* ++ * Return a pointer to the specified line number. ++ */ ++static LINE * ++findLine(NUM num) +{ -+ line_t *lp; -+ long i; ++ LINE * lp; ++ NUM lnum; + -+ for (lp = np; lp != mp; lp = lp->q_forw) -+ for (i = 0; i < active_last; i++) -+ if (active_list[active_ndx] == lp) ++ if ((num < 1) || (num > lastNum)) + { -+ active_list[active_ndx] = NULL; -+ active_ndx = INC_MOD (active_ndx, active_last - 1); -+ break; ++ fprintf(stderr, "Line number %d does not exist\n", num); ++ ++ return NULL; + } -+ else -+ active_ndx = INC_MOD (active_ndx, active_last - 1); -+} + ++ if (curNum <= 0) ++ { ++ curNum = 1; ++ curLine = lines.next; ++ } + -+/* 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; -+} ++ if (num == curNum) ++ return curLine; + ++ lp = curLine; ++ lnum = curNum; + -+/* 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 (); -+} ++ if (num < (curNum / 2)) ++ { ++ lp = lines.next; ++ lnum = 1; ++ } ++ else if (num > ((curNum + lastNum) / 2)) ++ { ++ lp = lines.prev; ++ lnum = lastNum; ++ } + ++ while (lnum < num) ++ { ++ lp = lp->next; ++ lnum++; ++ } + ++ while (lnum > num) ++ { ++ lp = lp->prev; ++ lnum--; ++ } + -+/* 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; ++ return lp; +} + + -+/* extract_pattern: copy a pattern string from the command buffer; return -+ pointer to the copy */ -+char * -+extract_pattern (delimiter) -+ int delimiter; ++/* ++ * Set the current line number. ++ * Returns TRUE if successful. ++ */ ++static BOOL ++setCurNum(NUM num) +{ -+ 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; -+} ++ LINE * lp; + ++ lp = findLine(num); + -+/* 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 $ -+*/ ++ if (lp == NULL) ++ return FALSE; + -+#include <stdio.h> ++ curNum = num; ++ curLine = lp; ++ ++ return TRUE; ++} + -+#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; ++/* END CODE */ |