# HG changeset patch
# User roug
# Date 1046034697 0
# Node ID bef1844de0dc5fb3bf3796f0b9c21f2b5ec2bcc5
# Parent  57b5e715a41757a30705bd64a3f02cb8c6883418
The ED editor ported from Minix

diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/README
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/README	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,13 @@
+The Unix ed-editor ported from Minix to OS9 Level One.
+
+Old UNIX-hands will recognize this simple editor. What makes this editor
+still relevant is that it fits in the memory space of OS9 Level One,
+it is completely independent of terminal command sequences and it can
+be fed instructions from a script.
+
+To build it on OS9 type:
+
+shell compile
+shell makelib
+shell makeed
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/amatch.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/amatch.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,129 @@
+/*      amatch.c        */
+#include <stdio.h>
+#include "tools.h"
+
+/*     Scans throught the pattern template looking for a match
+ * with lin.  Each element of lin is compared with the template
+ * until either a mis-match is found or the end of the template
+ * is reached.  In the former case a 0 is returned; in the latter,
+ * a pointer into lin (pointing to the character following the
+ * matched pattern) is returned.
+ *
+ *      "lin"   is a pointer to the line being searched.
+ *      "pat"   is a pointer to a template made by makepat().
+ *      "boln"  is a pointer into "lin" which points at the
+ *                      character at the beginning of the line.
+ */
+static char *match(); /* Predeclaration */
+
+char *paropen[9], *parclose[9];
+int between, parnum;
+
+char *amatch(lin, pat, boln)
+char *lin;
+TOKEN *pat;
+char *boln;
+{
+  between = 0;
+  parnum = 0;
+
+  lin = match(lin, pat, boln);
+
+  if (between) return 0;
+
+  while (parnum < 9) {
+        paropen[parnum] = parclose[parnum] = "";
+        parnum++;
+  }
+  return lin;
+}
+
+static char *match(lin, pat, boln)
+char *lin;
+TOKEN *pat;
+char *boln;
+{
+  register char *bocl, *rval, *strstart;
+
+  if (pat == 0) return 0;
+
+  strstart = lin;
+
+  while (pat) {
+        if (pat->tok == CLOSURE && pat->next) {
+                /* Process a closure: first skip over the closure
+                 * token to the object to be repeated.  This object
+                 * can be a character class. */
+
+                pat = pat->next;
+
+                /* Now match as many occurrences of the closure
+                 * pattern as possible. */
+                bocl = lin;
+
+                while (*lin && omatch(&lin, pat, boln));
+
+                /* 'Lin' now points to the character that made made
+                 * us fail.  Now go on to process the rest of the
+                 * string.  A problem here is a character following
+                 * the closure which could have been in the closure.
+                 * For example, in the pattern "[a-z]*t" (which
+                 * matches any lower-case word ending in a t), the
+                 * final 't' will be sucked up in the while loop.
+                 * So, if the match fails, we back up a notch and try
+                 * to match the rest of the string again, repeating
+                 * this process recursively until we get back to the
+                 * beginning of the closure.  The recursion goes, at
+                 * most two levels deep. */
+
+                if (pat = pat->next) {
+                        int savbtwn = between;
+                        int savprnm = parnum;
+
+                        while (bocl <= lin) {
+                                if (rval = match(lin, pat, boln)) {
+                                        /* Success */
+                                        return(rval);
+                                } else {
+                                        --lin;
+                                        between = savbtwn;
+                                        parnum = savprnm;
+                                }
+                        }
+                        return(0);      /* match failed */
+                }
+        } else if (pat->tok == OPEN) {
+                if (between || parnum >= 9) return 0;
+                paropen[parnum] = lin;
+                between = 1;
+                pat = pat->next;
+        } else if (pat->tok == CLOSE) {
+                if (!between) return 0;
+                parclose[parnum++] = lin;
+                between = 0;
+                pat = pat->next;
+        } else if (omatch(&lin, pat, boln)) {
+                pat = pat->next;
+        } else {
+                return(0);
+        }
+  }
+
+  /* Note that omatch() advances lin to point at the next character to
+   * be matched.  Consequently, when we reach the end of the template,
+   * lin will be pointing at the character following the last character
+   * matched.  The exceptions are templates containing only a BOLN or
+   * EOLN token.  In these cases omatch doesn't advance.
+   *
+   * A philosophical point should be mentioned here.  Is $ a position or a
+   * character? (i.e. does $ mean the EOL character itself or does it
+   * mean the character at the end of the line.)  I decided here to
+   * make it mean the former, in order to make the behavior of match()
+   * consistent.  If you give match the pattern ^$ (match all lines
+   * consisting only of an end of line) then, since something has to be
+   * returned, a pointer to the end of line character itself is
+   * returned. */
+
+  return((char *) max(strstart, lin));
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/append.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/append.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,24 @@
+/*      append.c        */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+int append(line, glob)
+int line, glob;
+{
+  int stat;
+  char lin[MAXLINE];
+
+  if (glob) return(ERR);
+  curln = line;
+  while (1) {
+        if (nflg) printf("%6d. ", curln + 1);
+
+        if (fgets(lin, MAXLINE, stdin) == NULL) return(EOF);
+        if (lin[0] == '.' && lin[1] == '\n') return (0);
+        stat = ins(lin);
+        if (stat < 0) return(ERR);
+
+  }
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/bitmap.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/bitmap.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,70 @@
+/*      bitmap.c        */
+/*
+ *      BITMAP.C -      makebitmap, setbit, testbit
+ *                      bit-map manipulation routines.
+ *
+ *      Copyright (c) Allen I. Holub, all rights reserved.  This program may
+ *              for copied for personal, non-profit use only.
+ *
+ */
+
+#ifdef DEBUG
+#include <stdio.h>
+#endif
+
+#include "tools.h"
+
+BITMAP *makebitmap(size)
+unsigned size;
+{
+  /* Make a bit map with "size" bits.  The first entry in the map is an
+   * "unsigned int" representing the maximum bit.  The map itself is
+   * concatenated to this integer. Return a pointer to a map on
+   * success, 0 if there's not enough memory. */
+
+  unsigned *map, numbytes;
+
+  numbytes = (size >> 3) + ((size & 0x07) ? 1 : 0);
+
+#ifdef DEBUG
+  printf("Making a %d bit map (%d bytes required)\n", size, numbytes);
+#endif
+
+  if (map = (unsigned *) malloc(numbytes + sizeof(unsigned))) *map = size;
+
+  return((BITMAP *) map);
+}
+
+int setbit(c, map, val)
+unsigned c, val;
+char *map;
+{
+  /* Set bit c in the map to val. If c > map-size, 0 is returned, else
+   * 1 is returned. */
+
+  if (c >= *(unsigned *) map)   /* if c >= map size */
+        return 0;
+
+  map += sizeof(unsigned);      /* skip past size */
+
+  if (val)
+        map[c >> 3] |= 1 << (c & 0x07);
+  else
+        map[c >> 3] &= ~(1 << (c & 0x07));
+
+  return 1;
+}
+
+int testbit(c, map)
+unsigned c;
+char *map;
+{
+  /* Return 1 if the bit corresponding to c in map is set. 0 if it is not. */
+
+  if (c >= *(unsigned *) map) return 0;
+
+  map += sizeof(unsigned);
+
+  return(map[c >> 3] & (1 << (c & 0x07)));
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/catsub.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/catsub.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,37 @@
+/*      catsub.c        */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+extern char *paropen[9], *parclose[9];
+
+char *catsub(from, to, sub, new, newend)
+char *from, *to, *sub, *new, *newend;
+{
+  char *cp, *cp2;
+
+  for (cp = new; *sub != EOS && cp < newend;) {
+        if (*sub == DITTO) for (cp2 = from; cp2 < to;) {
+                        *cp++ = *cp2++;
+                        if (cp >= newend) break;
+                }
+        else if (*sub == ESCAPE) {
+                sub++;
+                if ('1' <= *sub && *sub <= '9') {
+                        char *parcl = parclose[*sub - '1'];
+
+                        for (cp2 = paropen[*sub - '1']; cp2 < parcl;) {
+                                *cp++ = *cp2++;
+                                if (cp >= newend) break;
+                        }
+                } else
+                        *cp++ = *sub;
+        } else
+                *cp++ = *sub;
+
+        sub++;
+  }
+
+  return(cp);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/ckglob.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/ckglob.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,43 @@
+/*      ckglob.c        */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+int ckglob()
+{
+  TOKEN *glbpat;
+  char c, delim;
+  char lin[MAXLINE];
+  int num;
+  LINE *ptr;
+
+  c = *inptr;
+
+  if (c != 'g' && c != 'v') return(0);
+
+  if (deflt(1, lastln) < 0) return(ERR);
+
+  delim = *++inptr;
+  if (delim <= ' ') return(ERR);
+
+  glbpat = optpat();
+
+  if (*inptr == delim) inptr++;
+
+  ptr = getptr(1);
+  for (num = 1; num <= lastln; num++) {
+        ptr->l_stat &= ~LGLOB;
+        if (line1 <= num && num <= line2) {
+                strcpy(lin, ptr->l_buff);
+                strcat(lin, "\n");
+                if (matchs(lin, glbpat, 0)) {
+                        if (c == 'g') ptr->l_stat |= LGLOB;
+                } else {
+                        if (c == 'v') ptr->l_stat |= LGLOB;
+                }
+        }
+        ptr = ptr->l_next;
+  }
+  return(1);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/compile
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/compile	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,37 @@
+cc1 -r amatch.c
+cc1 -r append.c
+cc1 -r bitmap.c
+cc1 -r catsub.c
+cc1 -r ckglob.c
+cc1 -r deflt.c
+cc1 -r del.c
+cc1 -r docmd.c
+cc1 -r dodash.c
+cc1 -r doglob.c
+cc1 -r doprnt.c
+cc1 -r doread.c
+cc1 -r dowrite.c
+cc1 -r ed.c
+cc1 -r egets.c
+cc1 -r esc.c
+cc1 -r find.c
+cc1 -r getfn.c
+cc1 -r getlst.c
+cc1 -r getnum.c
+cc1 -r getone.c
+cc1 -r getpat.c
+cc1 -r getptr.c
+cc1 -r getrhs.c
+cc1 -r gettxt.c
+cc1 -r ins.c
+cc1 -r join.c
+cc1 -r makepat.c
+cc1 -r maksub.c
+cc1 -r matchs.c
+cc1 -r move.c
+cc1 -r omatch.c
+cc1 -r optpat.c
+cc1 -r set.c
+cc1 -r setbuf.c
+cc1 -r subst.c
+cc1 -r unmkpat.c
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/deflt.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/deflt.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,16 @@
+/*      deflt.c */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+int deflt(def1, def2)
+int def1, def2;
+{
+  if (nlines == 0) {
+        line1 = def1;
+        line2 = def2;
+  }
+  if (line1 > line2 || line1 <= 0) return(ERR);
+  return(0);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/del.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/del.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,25 @@
+/*      del.c   */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+int del(from, to)
+int from, to;
+{
+  LINE *first, *last, *next, *tmp;
+
+  if (from < 1) from = 1;
+  first = getptr(prevln(from));
+  last = getptr(nextln(to));
+  next = first->l_next;
+  while (next != last && next != &line0) {
+        tmp = next->l_next;
+        free((char *) next);
+        next = tmp;
+  }
+  relink(first, last, first, last);
+  lastln -= (to - from) + 1;
+  curln = prevln(from);
+  return(0);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/docmd.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/docmd.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,243 @@
+/*      docmd.c */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+char fname[MAXFNAME];
+int fchanged;
+extern int nofname;
+
+extern int mark[];
+
+int docmd(glob)
+int glob;
+{
+  static char rhs[MAXPAT];
+  TOKEN *subpat;
+  int c, err, line3;
+  int apflg, pflag, gflag;
+  int nchng;
+  char *fptr;
+
+  pflag = FALSE;
+  while (*inptr == SP && *inptr == HT) inptr++;
+
+  c = *inptr++;
+
+  switch (c) {
+      case NL:
+        if (nlines == 0) {
+                if ((line2 = nextln(curln)) == 0) return(ERR);
+        }
+        curln = line2;
+        return(1);
+        break;
+
+      case '=': printf("%d\n", line2);  break;
+
+      case 'a':
+        if (*inptr != NL || nlines > 1) return(ERR);
+
+        if (append(line1, glob) < 0) return(ERR);;
+        fchanged = TRUE;
+        break;
+
+      case 'c':
+        if (*inptr != NL) return(ERR);
+
+        if (deflt(curln, curln) < 0) return(ERR);
+
+        if (del(line1, line2) < 0) return(ERR);
+        if (append(curln, glob) < 0) return (ERR);
+        fchanged = TRUE;
+        break;
+
+      case 'd':
+        if (*inptr != NL) return(ERR);
+
+        if (deflt(curln, curln) < 0) return(ERR);
+
+        if (del(line1, line2) < 0) return(ERR);
+        if (nextln(curln) != 0) curln = nextln(curln);
+        fchanged = TRUE;
+        break;
+
+      case 'e':
+        if (nlines > 0) return(ERR);
+        if (fchanged) {
+                fchanged = FALSE;
+                return(ERR);
+        }
+
+        /* FALL THROUGH */
+      case 'E':
+        if (nlines > 0) return(ERR);
+
+        if (*inptr != ' ' && *inptr != HT && *inptr != NL) return(ERR);
+
+        if ((fptr = getfn()) == NULL) return(ERR);
+
+        clrbuf();
+        if ((err = doread(0, fptr)) < 0) return(err);
+
+        strcpy(fname, fptr);
+        fchanged = FALSE;
+        break;
+
+      case 'f':
+        if (nlines > 0) return(ERR);
+
+        if (*inptr != ' ' && *inptr != HT && *inptr != NL) return(ERR);
+
+        if ((fptr = getfn()) == NULL) return(ERR);
+
+        if (nofname)
+                printf("%s\n", fname);
+        else
+                strcpy(fname, fptr);
+        break;
+
+      case 'i':
+        if (*inptr != NL || nlines > 1) return(ERR);
+
+        if (append(prevln(line1), glob) < 0) return(ERR);
+        fchanged = TRUE;
+        break;
+
+      case 'j':
+        if (*inptr != NL || deflt(curln, curln + 1) < 0) return(ERR);
+
+        if (join(line1, line2) < 0) return(ERR);
+        break;
+
+      case 'k':
+        while (*inptr == ' ' || *inptr == HT) inptr++;
+
+        if (*inptr < 'a' || *inptr > 'z') return ERR;
+        c = *inptr++;
+
+        if (*inptr != ' ' && *inptr != HT && *inptr != NL) return(ERR);
+
+        mark[c - 'a'] = line1;
+        break;
+
+      case 'l':
+        if (*inptr != NL) return(ERR);
+        if (deflt(curln, curln) < 0) return (ERR);
+        if (dolst(line1, line2) < 0) return (ERR);
+        break;
+
+      case 'm':
+        if ((line3 = getone()) < 0) return(ERR);
+        if (deflt(curln, curln) < 0) return (ERR);
+        if (move(line3) < 0) return (ERR);
+        fchanged = TRUE;
+        break;
+
+      case 'P':
+      case 'p':
+        if (*inptr != NL) return(ERR);
+        if (deflt(curln, curln) < 0) return (ERR);
+        if (doprnt(line1, line2) < 0) return (ERR);
+        break;
+
+      case 'q':
+        if (fchanged) {
+                fchanged = FALSE;
+                return(ERR);
+        }
+
+        /* FALL THROUGH */
+      case 'Q':
+        if (*inptr == NL && nlines == 0 && !glob)
+                return(EOF);
+        else
+                return(ERR);
+
+      case 'r':
+        if (nlines > 1) return(ERR);
+
+        if (nlines == 0) line2 = lastln;
+
+        if (*inptr != ' ' && *inptr != HT && *inptr != NL) return(ERR);
+
+        if ((fptr = getfn()) == NULL) return(ERR);
+
+        if ((err = doread(line2, fptr)) < 0) return(err);
+        fchanged = TRUE;
+        break;
+
+      case 's':
+        if (*inptr == 'e') return(set());
+        while (*inptr == SP || *inptr == HT) inptr++;
+        if ((subpat = optpat()) == NULL) return (ERR);
+        if ((gflag = getrhs(rhs)) < 0) return (ERR);
+        if (*inptr == 'p') pflag++;
+        if (deflt(curln, curln) < 0) return (ERR);
+        if ((nchng = subst(subpat, rhs, gflag, pflag)) < 0) return (ERR);
+        if (nchng) fchanged = TRUE;
+        break;
+
+      case 't':
+        if ((line3 = getone()) < 0) return(ERR);
+        if (deflt(curln, curln) < 0) return (ERR);
+        if (transfer(line3) < 0) return (ERR);
+        fchanged = TRUE;
+        break;
+
+      case 'W':
+      case 'w':
+        apflg = (c == 'W');
+
+        if (*inptr != ' ' && *inptr != HT && *inptr != NL) return(ERR);
+
+        if ((fptr = getfn()) == NULL) return(ERR);
+
+        if (deflt(1, lastln) < 0) return(ERR);
+        if (dowrite(line1, line2, fptr, apflg) < 0) return (ERR);
+        fchanged = FALSE;
+        break;
+
+      case 'x':
+        if (*inptr == NL && nlines == 0 && !glob) {
+                if ((fptr = getfn()) == NULL) return(ERR);
+                if (dowrite(1, lastln, fptr, 0) >= 0) return (EOF);
+        }
+        return(ERR);
+
+      case 'z':
+        if (deflt(curln, curln) < 0) return(ERR);
+
+        switch (*inptr) {
+            case '-':
+                if (doprnt(line1 - 21, line1) < 0) return(ERR);
+                break;
+
+            case '.':
+                if (doprnt(line1 - 11, line1 + 10) < 0) return(ERR);
+                break;
+
+            case '+':
+            case '\n':
+                if (doprnt(line1, line1 + 21) < 0) return(ERR);
+                break;
+        }
+        break;
+
+      default:  return(ERR);
+}
+  return(0);
+}
+
+int dolst(line1, line2)
+int line1, line2;
+{
+  int oldlflg = lflg, p;
+
+  lflg = 1;
+  p = doprnt(line1, line2);
+  lflg = oldlflg;
+
+  return p;
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/dodash.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/dodash.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,50 @@
+/*      dodash.c        */
+#include <stdio.h>
+#include "tools.h"
+
+/*      Expand the set pointed to by *src into dest.
+ *      Stop at delim.  Return 0 on error or size of
+ *      character class on success.  Update *src to
+ *      point at delim.  A set can have one element
+ *      {x} or several elements ( {abcdefghijklmnopqrstuvwxyz}
+ *      and {a-z} are equivalent ).  Note that the dash
+ *      notation is expanded as sequential numbers.
+ *      This means (since we are using the ASCII character
+ *      set) that a-Z will contain the entire alphabet
+ *      plus the symbols: [\]^_`.  The maximum number of
+ *      characters in a character class is defined by maxccl.
+ */
+char *dodash(delim, src, map)
+int delim;
+char *src, *map;
+{
+
+  register int first, last;
+  char *start;
+
+  start = src;
+
+  while (*src && *src != delim) {
+        if (*src != '-') setbit(esc(&src), map, 1);
+
+        else if (src == start || *(src + 1) == delim)
+                setbit('-', map, 1);
+        else {
+                src++;
+
+                if (*src < *(src - 2)) {
+                        first = *src;
+                        last = *(src - 2);
+                } else {
+                        first = *(src - 2);
+                        last = *src;
+                }
+
+                while (++first <= last) setbit(first, map, 1);
+
+        }
+        src++;
+  }
+  return(src);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/doglob.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/doglob.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,30 @@
+/*      doglob.c        */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+int doglob()
+{
+  int lin, stat;
+  char *cmd;
+  LINE *ptr;
+
+  cmd = inptr;
+
+  while (1) {
+        ptr = getptr(1);
+        for (lin = 1; lin <= lastln; lin++) {
+                if (ptr->l_stat & LGLOB) break;
+                ptr = ptr->l_next;
+        }
+        if (lin > lastln) break;
+
+        ptr->l_stat &= ~LGLOB;
+        curln = lin;
+        inptr = cmd;
+        if ((stat = getlst()) < 0) return(stat);
+        if ((stat = docmd(1)) < 0) return (stat);
+  }
+  return(curln);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/doprnt.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/doprnt.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,65 @@
+/*      doprnt.c        */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+int doprnt(from, to)
+int from, to;
+{
+  int i;
+  LINE *lptr;
+
+  from = from < 1 ? 1 : from;
+  to = to > lastln ? lastln : to;
+
+  if (to != 0) {
+        lptr = getptr(from);
+        for (i = from; i <= to; i++) {
+                prntln(lptr->l_buff, lflg, (nflg ? i : 0));
+                lptr = lptr->l_next;
+        }
+        curln = to;
+  }
+  return(0);
+}
+
+prntln(str, vflg, lin)
+char *str;
+int vflg, lin;
+{
+  if (lin) printf("%7d ", lin);
+  while (*str && *str != NL) {
+        if (*str < ' ' || *str >= 0x7f) {
+                switch (*str) {
+                    case '\t':
+                        if (vflg)
+                                putcntl(*str, stdout);
+                        else
+                                putc(*str, stdout);
+                        break;
+
+                    case DEL:
+                        putc('^', stdout);
+                        putc('?', stdout);
+                        break;
+
+                    default:
+                        putcntl(*str, stdout);
+                        break;
+                }
+        } else
+                putc(*str, stdout);
+        str++;
+  }
+  if (vflg) putc('$', stdout);
+  putc('\n', stdout);
+}
+
+putcntl(c, stream)
+char c;
+FILE *stream;
+{
+  putc('^', stream);
+  putc((c & 31) | '@', stream);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/doread.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/doread.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,47 @@
+/*      doread.c        */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+extern int diag;
+
+int doread(lin, fname)
+int lin;
+char *fname;
+{
+  FILE *fp;
+  int err;
+  long bytes;
+  int lines;
+  static char str[MAXLINE];
+
+  err = 0;
+  nonascii = nullchar = truncated = 0;
+
+  if (diag) printf("\"%s\" ", fname);
+  if ((fp = fopen(fname, "r")) == NULL) {
+        printf("file open err\n");
+        return(ERR);
+  }
+  curln = lin;
+  for (lines = 0, bytes = 0; (err = egets(str, MAXLINE, fp)) > 0;) {
+        bytes += strlen(str);
+        if (ins(str) < 0) {
+                printf("file insert error\n");
+                err++;
+                break;
+        }
+        lines++;
+  }
+  fclose(fp);
+  if (err < 0) return(err);
+  if (diag) {
+        printf("%d lines %ld bytes", lines, bytes);
+        if (nonascii) printf(" [%d non-ascii]", nonascii);
+        if (nullchar) printf(" [%d nul]", nullchar);
+        if (truncated) printf(" [%d lines truncated]", truncated);
+        printf("\n");
+  }
+  return(err);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/dowrite.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/dowrite.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,45 @@
+/*      dowrite.c       */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+extern int diag;
+
+int dowrite(from, to, fname, apflg)
+int from, to;
+char *fname;
+int apflg;
+{
+  FILE *fp;
+  int lin, err;
+  int lines;
+  long bytes;
+  char *str;
+  LINE *lptr;
+
+  err = 0;
+
+  lines = bytes = 0;
+  if (diag) printf("\"%s\" ", fname);
+  if ((fp = fopen(fname, (apflg ? "a" : "w"))) == NULL) {
+        printf("file open error\n");
+        return(ERR);
+  }
+  lptr = getptr(from);
+  for (lin = from; lin <= to; lin++) {
+        str = lptr->l_buff;
+        lines++;
+        bytes += strlen(str) + 1;
+        if (fputs(str, fp) == EOF) {
+                printf("file write error\n");
+                err++;
+                break;
+        }
+        putc('\n', fp);
+        lptr = lptr->l_next;
+  }
+  if (diag) printf("%d lines %ld bytes\n", lines, bytes);
+  fclose(fp);
+  return(err);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/ed.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/ed.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,99 @@
+/*      ed.c    */
+/* Copyright 1987 Brian Beattie Rights Reserved.
+ *
+ * Permission to copy and/or distribute granted under the
+ * following conditions:
+ *
+ * 1). No charge may be made other than resonable charges
+ *      for reproduction.
+ *
+ * 2). This notice must remain intact.
+ *
+ * 3). No further restrictions may be added.
+ *
+ */
+#include <stdio.h>
+#include <signal.h>
+#include "tools.h"
+#include "ed.h"
+#include <setjmp.h>
+jmp_buf env;
+
+#define isatty(fd) 1
+
+LINE line0;
+int curln = 0;
+int lastln = 0;
+char *inptr;
+static char inlin[MAXLINE];
+int nflg, lflg;
+int line1, line2, nlines;
+extern char fname[];
+int version = 1;
+int diag = 1;
+
+intr(sig)
+int sig;
+{
+  printf("?\n");
+  longjmp(env, 1);
+}
+
+int main(argc, argv)
+int argc;
+char **argv;
+{
+  int stat, i, doflush;
+
+  pflinit();
+  set_buf();
+  doflush = isatty(1);
+
+  if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 0) {
+        diag = 0;
+        argc--;
+        argv++;
+  }
+  if (argc > 1) {
+        for (i = 1; i < argc; i++) {
+                if (doread(0, argv[i]) == 0) {
+                        curln = 1;
+                        strcpy(fname, argv[i]);
+                        break;
+                }
+        }
+  }
+  while (1) {
+        setjmp(env);
+        if (signal(SIGINT, SIG_IGN) != SIG_IGN) signal(SIGINT, intr);
+
+        if (doflush) fflush(stdout);
+
+        if (fgets(inlin, sizeof(inlin), stdin) == NULL) {
+                break;
+        }
+        inptr = inlin;
+        if (getlst() >= 0)
+                if ((stat = ckglob()) != 0) {
+                        if (stat >= 0 && (stat = doglob()) >= 0) {
+                                curln = stat;
+                                continue;
+                        }
+                } else {
+                        if ((stat = docmd(0)) >= 0) {
+                                if (stat == 1) doprnt(curln, curln);
+                                continue;
+                        }
+                }
+        if (stat == EOF) {
+                exit(0);
+        }
+        if (stat == FATAL) {
+                fputs("FATAL ERROR\n", stderr);
+                exit(1);
+        }
+        printf("?\n");
+  }
+  return(0);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/ed.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/ed.h	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,37 @@
+/*      ed.h    */
+#define FATAL   (ERR-1)
+struct line {
+  int l_stat;                   /* empty, mark */
+  struct line *l_prev;
+  struct line *l_next;
+  char l_buff[1];
+};
+
+typedef struct line LINE;
+
+#define LINFREE 1               /* entry not in use */
+#define LGLOB   2               /* line marked global */
+
+                                /* max number of chars per line */
+#define MAXLINE (sizeof(int) == 2 ? 256 : 8192)
+#define MAXPAT  256             /* max number of chars per replacement
+                                 * pattern */
+                                /* max file name size */
+#define MAXFNAME (sizeof(int) == 2 ? 256 : 1024)
+
+extern LINE line0;
+extern int curln, lastln, line1, line2, nlines;
+extern int nflg;                /* print line number flag */
+extern int lflg;                /* print line in verbose mode */
+extern char *inptr;             /* tty input buffer */
+extern char linbuf[], *linptr;  /* current line */
+extern int truncflg;            /* truncate long line flag */
+extern int eightbit;            /* save eighth bit */
+extern int nonascii;            /* count of non-ascii chars read */
+extern int nullchar;            /* count of null chars read */
+extern int truncated;           /* count of lines truncated */
+extern int fchanged;            /* file changed */
+
+#define nextln(l)       ((l)+1 > lastln ? 0 : (l)+1)
+#define prevln(l)       ((l)-1 < 0 ? lastln : (l)-1)
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/ed.refentry
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/ed.refentry	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,131 @@
+<refentry id="ed">
+<refnamediv>
+<refname>ED</refname>
+<refpurpose>editor</refpurpose>
+</refnamediv>
+
+<refsynopsisdiv>
+<cmdsynopsis>
+<command>ED</command>
+<arg choice="plain"><replaceable>file</replaceable></arg>
+<arg choice="opt">-</arg>
+</cmdsynopsis>
+</refsynopsisdiv>
+
+<refsect1><title>Options</title>
+<para>
+"-" Suppress line/byte count messages (for in scripts)
+</para>
+</refsect1>
+<refsect1><title>Examples</title>
+<screen>
+ed prog.c                Edit <filename>prog.c</filename>
+echo '1,$p' | ed - file  Odd way to write 'cat file'
+</screen>
+</refsect1>
+<refsect1><title>Description</title>
+<para>
+<command>Ed</command> is functionally equivalent to the standard UNIX V7 editor, ed.  
+It supports the following commands:
+</para>
+<informaltable frame="none">
+<tgroup cols="2">
+<colspec colwidth="0.7in"/>
+<colspec colwidth="2.95in"/>
+<tbody>
+<row>
+<entry>(.)</entry><entry>a: append</entry>
+</row>
+<row>
+<entry>(.,.)</entry><entry>c: change</entry>
+</row>
+<row>
+<entry>(.,.)</entry><entry>d: delete</entry>
+</row>
+<row>
+<entry></entry><entry>e: edit new file"</entry>
+</row>
+<row>
+<entry></entry><entry>f: print name of edited file"</entry>
+</row>
+<row>
+<entry>(1,$)</entry><entry>g: global command</entry>
+</row>
+<row>
+<entry>(.)</entry><entry>i: insert</entry>
+</row>
+<row>
+<entry>(.,.+1)</entry><entry>j: join lines together</entry>
+</row>
+<row>
+<entry>(.)</entry><entry>k: mark</entry>
+</row>
+<row>
+<entry>(.)</entry><entry>l: print with special characters in octal</entry>
+</row>
+<row>
+<entry>(.,.)</entry><entry>m: move</entry>
+</row>
+<row>
+<entry>(.,.)</entry><entry>p: print</entry>
+</row>
+<row>
+<entry></entry><entry>q: quit editor"</entry>
+</row>
+<row>
+<entry>(.)</entry><entry>r: read in new file</entry>
+</row>
+<row>
+<entry>(.,.)</entry><entry>s: substitute</entry>
+</row>
+<row>
+<entry>(1,$)</entry><entry>v: like g, except select lines that do not match</entry>
+</row>
+<row>
+<entry>(1,$)</entry><entry>w: write out edited file</entry>
+</row>
+</tbody>
+</tgroup>
+</informaltable>
+<para>
+Many of the commands can take one or two addresses, as indicated above.  The
+defaults are shown in parentheses.  Thus <command>a</command> appends to the current 
+line, and <command>g</command> works on the whole file as default.  
+The dot refers to the current line.
+Below is a sample editing session with comments given following the # symbol.
+</para>
+<informaltable frame="none">
+<tgroup cols="2">
+<colspec colwidth="1.3in"/>
+<colspec colwidth="3.5in"/>
+<tbody>
+<row>
+<entry>ed prog.c</entry><entry># Edit prog.c</entry>
+</row>
+<row>
+<entry>3,20p</entry><entry># Print lines 3 through 20</entry>
+</row>
+<row>
+<entry>/whole/</entry><entry># Find next occurence of <replaceable>whole</replaceable></entry>
+</row>
+<row>
+<entry>s/whole/while/</entry><entry># Replace <replaceable>whole</replaceable> by <replaceable>while</replaceable></entry>
+</row>
+<row>
+<entry>g/Buf/s//BUF/g</entry><entry># Replace <replaceable>Buf</replaceable> by <replaceable>BUF</replaceable> everywhere</entry>
+</row>
+<row>
+<entry>w</entry><entry># Write the file back</entry>
+</row>
+<row>
+<entry>q</entry><entry># Exit the editor</entry>
+</row>
+</tbody>
+</tgroup>
+</informaltable>
+<para>
+<command>Ed</command> is provided for its sentimental value.
+</para>
+</refsect1>
+</refentry>
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/egets.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/egets.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,51 @@
+/*      egets.c */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+int eightbit = 1;               /* save eight bit */
+int nonascii, nullchar, truncated;
+int egets(str, size, stream)
+char *str;
+int size;
+FILE *stream;
+{
+  int c, count;
+  char *cp;
+
+  for (count = 0, cp = str; size > count;) {
+        c = getc(stream);
+        if (c == EOF) {
+                *cp++ = '\n';
+                *cp = EOS;
+                if (count) {
+                        printf("[Incomplete last line]\n");
+                }
+                return(count);
+        }
+        if (c == NL) {
+                *cp++ = c;
+                *cp = EOS;
+                return(++count);
+        }
+        if (c > 127) {
+                if (!eightbit)  /* if not saving eighth bit */
+                        c = c & 127;    /* strip eigth bit */
+                nonascii++;     /* count it */
+        }
+        if (c) {
+                *cp++ = c;      /* not null, keep it */
+                count++;
+        } else
+                nullchar++;     /* count nulls */
+  }
+  str[count - 1] = EOS;
+  if (c != NL) {
+        printf("truncating line\n");
+        truncated++;
+        while ((c = getc(stream)) != EOF)
+                if (c == NL) break;
+  }
+  return(count);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/esc.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/esc.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,33 @@
+/*      esc.c   */
+#include <stdio.h>
+#include "tools.h"
+
+/* Map escape sequences into their equivalent symbols.  Returns the
+ * correct ASCII character.  If no escape prefix is present then s
+ * is untouched and *s is returned, otherwise **s is advanced to point
+ * at the escaped character and the translated character is returned.
+ */
+int esc(s)
+char **s;
+{
+  register int rval;
+
+  if (**s != ESCAPE) {
+        rval = **s;
+  } else {
+        (*s)++;
+
+        switch (toupper(**s)) {
+            case '\000':        rval = ESCAPE;  break;
+            case 'S':   rval = ' ';     break;
+            case 'N':   rval = '\n';    break;
+            case 'T':   rval = '\t';    break;
+            case 'B':   rval = '\b';    break;
+            case 'R':   rval = '\r';    break;
+            default:    rval = **s;     break;
+        }
+  }
+
+  return(rval);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/find.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/find.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,33 @@
+/*      find.c  */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+int find(pat, dir)
+TOKEN *pat;
+int dir;
+{
+  int i, num;
+  char lin[MAXLINE];
+  LINE *ptr;
+
+  num = curln;
+  ptr = getptr(curln);
+  num = (dir ? nextln(num) : prevln(num));
+  ptr = (dir ? ptr->l_next : ptr->l_prev);
+  for (i = 0; i < lastln; i++) {
+        if (num == 0) {
+                num = (dir ? nextln(num) : prevln(num));
+                ptr = (dir ? ptr->l_next : ptr->l_prev);
+        }
+        strcpy(lin, ptr->l_buff);
+        strcat(lin, "\n");
+        if (matchs(lin, pat, 0)) {
+                return(num);
+        }
+        num = (dir ? nextln(num) : prevln(num));
+        ptr = (dir ? ptr->l_next : ptr->l_prev);
+  }
+  return(ERR);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/getfn.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/getfn.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,39 @@
+/*      getfn.c */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+extern char fname[MAXFNAME];
+int nofname;
+
+char *getfn()
+{
+  static char file[256];
+  char *cp;
+
+  if (*inptr == NL) {
+        nofname = TRUE;
+        strcpy(file, fname);
+  } else {
+        nofname = FALSE;
+        while (*inptr == SP || *inptr == HT) inptr++;
+
+        cp = file;
+        while (*inptr && *inptr != NL && *inptr != SP && *inptr != HT) {
+                *cp++ = *inptr++;
+        }
+        *cp = '\0';
+
+        if (strlen(file) == 0) {
+                printf("bad file name\n");
+                return(NULL);
+        }
+  }
+
+  if (strlen(file) == 0) {
+        printf("no file name\n");
+        return(NULL);
+  }
+  return(file);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/getlst.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/getlst.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,28 @@
+/*      getlst.c        */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+int getlst()
+{
+  int num;
+
+  line2 = 0;
+  for (nlines = 0; (num = getone()) >= 0;) {
+        line1 = line2;
+        line2 = num;
+        nlines++;
+        if (*inptr != ',' && *inptr != ';') break;
+        if (*inptr == ';') curln = num;
+        inptr++;
+  }
+  nlines = min(nlines, 2);
+  if (nlines == 0) line2 = curln;
+  if (nlines <= 1) line1 = line2;
+
+  if (num == ERR)
+        return(num);
+  else
+        return(nlines);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/getnum.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/getnum.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,53 @@
+/*      getnum.c        */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+int mark['z' - 'a' + 1];
+
+int getnum(first)
+int first;
+{
+  TOKEN *srchpat;
+  int num;
+  char c;
+
+  while (*inptr == SP || *inptr == HT) inptr++;
+
+  if (*inptr >= '0' && *inptr <= '9') { /* line number */
+        for (num = 0; *inptr >= '0' && *inptr <= '9';) {
+                num = (num * 10) + *inptr - '0';
+                inptr++;
+        }
+        return num;
+  }
+  switch (c = *inptr) {
+      case '.':
+        inptr++;
+        return(curln);
+
+      case '$':
+        inptr++;
+        return(lastln);
+
+      case '/':
+      case '?':
+        srchpat = optpat();
+        if (*inptr == c) inptr++;
+        return(find(srchpat, c == '/' ? 1 : 0));
+
+      case '-':
+      case '+':
+        return(first ? curln : 1);
+
+      case '\'':
+        inptr++;
+        if (*inptr < 'a' || *inptr > 'z') return(EOF);
+
+        return mark[*inptr++ - 'a'];
+
+      default:
+        return(first ? EOF : 1);/* unknown address */
+  }
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/getone.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/getone.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,31 @@
+/*      getone.c        */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+#define FIRST 1
+#define NOTFIRST 0
+
+int getone()
+{
+  int c, i, num;
+
+  if ((num = getnum(FIRST)) >= 0) {
+        while (1) {
+                while (*inptr == SP || *inptr == HT) inptr++;
+
+                if (*inptr != '+' && *inptr != '-') break;
+                c = *inptr++;
+
+                if ((i = getnum(NOTFIRST)) < 0) return(i);
+
+                if (c == '+') {
+                        num += i;
+                } else {
+                        num -= i;
+                }
+        }
+  }
+  return(num > lastln ? ERR : num);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/getpat.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/getpat.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,13 @@
+/*      getpat.c        */
+#include <stdio.h>
+#include "tools.h"
+
+/* Translate arg into a TOKEN string */
+TOKEN *
+ getpat(arg)
+char *arg;
+{
+
+  return(makepat(arg, '\000'));
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/getptr.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/getptr.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,22 @@
+/*      getptr.c        */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+LINE *
+ getptr(num)
+int num;
+{
+  LINE *ptr;
+  int j;
+
+  if (2 * num > lastln && num <= lastln) {      /* high line numbers */
+        ptr = line0.l_prev;
+        for (j = lastln; j > num; j--) ptr = ptr->l_prev;
+  } else {                      /* low line numbers */
+        ptr = &line0;
+        for (j = 0; j < num; j++) ptr = ptr->l_next;
+  }
+  return(ptr);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/getrhs.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/getrhs.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,22 @@
+/*      getrhs.c        */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+int getrhs(sub)
+char *sub;
+{
+  if (inptr[0] == NL || inptr[1] == NL) /* check for eol */
+        return(ERR);
+
+  if (maksub(sub, MAXPAT) == NULL) return(ERR);
+
+  inptr++;                      /* skip over delimter */
+  while (*inptr == SP || *inptr == HT) inptr++;
+  if (*inptr == 'g') {
+        inptr++;
+        return(1);
+  }
+  return(0);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/gettxt.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/gettxt.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,18 @@
+/*      gettxt.c        */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+char *
+ gettxt(num)
+int num;
+{
+  LINE *lin;
+  static char txtbuf[MAXLINE];
+
+  lin = getptr(num);
+  strcpy(txtbuf, lin->l_buff);
+  strcat(txtbuf, "\n");
+  return(txtbuf);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/ins.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/ins.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,37 @@
+/*      ins.c   */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+int ins(str)
+char *str;
+{
+  char buf[MAXLINE], *cp;
+  LINE *new, *cur, *nxt;
+
+  cp = buf;
+  while (1) {
+        if ((*cp = *str++) == NL) *cp = EOS;
+        if (*cp) {
+                cp++;
+                continue;
+        }
+        if ((new = (LINE *) malloc(sizeof(LINE) + strlen(buf))) == NULL)
+                return(ERR);    /* no memory */
+
+        new->l_stat = 0;
+        strcpy(new->l_buff, buf);       /* build new line */
+        cur = getptr(curln);    /* get current line */
+        nxt = cur->l_next;      /* get next line */
+        relink(cur, new, new, nxt);     /* add to linked list */
+        relink(new, nxt, cur, new);
+        lastln++;
+        curln++;
+
+        if (*str == EOS)        /* end of line ? */
+                return(1);
+
+        cp = buf;
+  }
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/join.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/join.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,38 @@
+/*      join.c  */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+extern int fchanged;
+
+int join(first, last)
+int first, last;
+{
+  char buf[MAXLINE];
+  char *cp = buf, *str;
+  int num;
+
+  if (first <= 0 || first > last || last > lastln) return(ERR);
+  if (first == last) {
+        curln = first;
+        return 0;
+  }
+  for (num = first; num <= last; num++) {
+        str = gettxt(num);
+
+        while (*str != NL && cp < buf + MAXLINE - 1) *cp++ = *str++;
+
+        if (cp == buf + MAXLINE - 1) {
+                printf("line too long\n");
+                return(ERR);
+        }
+  }
+  *cp++ = NL;
+  *cp = EOS;
+  del(first, last);
+  curln = first - 1;
+  ins(buf);
+  fchanged = TRUE;
+  return 0;
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/makeed
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/makeed	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,1 @@
+cc1 ed.c objs.l -f=ed
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/makelib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/makelib	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,10 @@
+t
+-x
+* Create a library
+merge >objs.1 bitmap.r append.r catsub.r ckglob.r deflt.r del.r doprnt.r
+merge >objs.2 doread.r dowrite.r egets.r find.r getfn.r getlst.r getone.r
+merge >objs.3 getptr.r getrhs.r gettxt.r getnum.r ins.r join.r maksub.r
+merge >objs.4 move.r optpat.r set.r setbuf.r getpat.r matchs.r amatch.r unmkpat.r
+merge >objs.5 omatch.r makepat.r  dodash.r esc.r subst.r docmd.r doglob.r
+merge >objs.l objs.1 objs.2 objs.3 objs.4 objs.5
+del objs.1 objs.2 objs.3 objs.4 objs.5
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/makepat.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/makepat.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,142 @@
+/*      makepat.c       */
+#include <stdio.h>
+#include "tools.h"
+
+/* Make a pattern template from the strinng pointed to by arg.  Stop
+ * when delim or '\000' or '\n' is found in arg.  Return a pointer to
+ * the pattern template.
+ *
+ * The pattern template used here are somewhat different than those
+ * used in the "Software Tools" book; each token is a structure of
+ * the form TOKEN (see tools.h).  A token consists of an identifier,
+ * a pointer to a string, a literal character and a pointer to another
+ * token.  This last is 0 if there is no subsequent token.
+ *
+ * The one strangeness here is caused (again) by CLOSURE which has
+ * to be put in front of the previous token.  To make this insertion a
+ * little easier, the 'next' field of the last to point at the chain
+ * (the one pointed to by 'tail) is made to point at the previous node.
+ * When we are finished, tail->next is set to 0.
+ */
+TOKEN *
+ makepat(arg, delim)
+char *arg;
+int delim;
+{
+  TOKEN *head, *tail, *ntok;
+  int error;
+
+  /* Check for characters that aren't legal at the beginning of a template. */
+
+  if (*arg == '\0' || *arg == delim || *arg == '\n' || *arg == CLOSURE)
+        return(0);
+
+  error = 0;
+  tail = head = NULL;
+
+  while (*arg && *arg != delim && *arg != '\n' && !error) {
+        ntok = (TOKEN *) malloc(TOKSIZE);
+        ntok->lchar = '\000';
+        ntok->next = 0;
+
+        switch (*arg) {
+            case ANY:   ntok->tok = ANY;        break;
+
+            case BOL:
+                if (head == 0)  /* then this is the first symbol */
+                        ntok->tok = BOL;
+                else
+                        ntok->tok = LITCHAR;
+                ntok->lchar = BOL;
+                break;
+
+            case EOL:
+                if (*(arg + 1) == delim || *(arg + 1) == '\000' ||
+                    *(arg + 1) == '\n') {
+                        ntok->tok = EOL;
+                } else {
+                        ntok->tok = LITCHAR;
+                        ntok->lchar = EOL;
+                }
+                break;
+
+            case CLOSURE:
+                if (head != 0) {
+                        switch (tail->tok) {
+                            case BOL:
+                            case EOL:
+                            case CLOSURE:
+                                return(0);
+
+                            default:
+                                ntok->tok = CLOSURE;
+                        }
+                }
+                break;
+
+            case CCL:
+
+                if (*(arg + 1) == NEGATE) {
+                        ntok->tok = NCCL;
+                        arg += 2;
+                } else {
+                        ntok->tok = CCL;
+                        arg++;
+                }
+
+                if (ntok->bitmap = makebitmap(CLS_SIZE))
+                        arg = dodash(CCLEND, arg, ntok->bitmap);
+                else {
+                        fprintf(stderr, "Not enough memory for pat\n");
+                        error = 1;
+                }
+                break;
+
+            default:
+                if (*arg == ESCAPE && *(arg + 1) == OPEN) {
+                        ntok->tok = OPEN;
+                        arg++;
+                } else if (*arg == ESCAPE && *(arg + 1) == CLOSE) {
+                        ntok->tok = CLOSE;
+                        arg++;
+                } else {
+                        ntok->tok = LITCHAR;
+                        ntok->lchar = esc(&arg);
+                }
+        }
+
+        if (error || ntok == 0) {
+                unmakepat(head);
+                return(0);
+        } else if (head == 0) {
+                /* This is the first node in the chain. */
+
+                ntok->next = 0;
+                head = tail = ntok;
+        } else if (ntok->tok != CLOSURE) {
+                /* Insert at end of list (after tail) */
+
+                tail->next = ntok;
+                ntok->next = tail;
+                tail = ntok;
+        } else if (head != tail) {
+                /* More than one node in the chain.  Insert the
+                 * CLOSURE node immediately in front of tail. */
+
+                (tail->next)->next = ntok;
+                ntok->next = tail;
+        } else {
+                /* Only one node in the chain,  Insert the CLOSURE
+                 * node at the head of the linked list. */
+
+                ntok->next = head;
+                tail->next = ntok;
+                head = ntok;
+        }
+        arg++;
+  }
+
+  tail->next = 0;
+  return(head);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/maksub.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/maksub.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,68 @@
+/*      maksub.c        */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+char *
+ maksub(sub, subsz)
+char *sub;
+int subsz;
+{
+  int size;
+  char delim, *cp;
+
+  size = 0;
+  cp = sub;
+
+  delim = *inptr++;
+  for (size = 0; *inptr != delim && *inptr != NL && size < subsz; size++) {
+        if (*inptr == '&') {
+                *cp++ = DITTO;
+                inptr++;
+        } else if ((*cp++ = *inptr++) == ESCAPE) {
+                if (size >= subsz) return(NULL);
+
+                switch (toupper(*inptr)) {
+                    case NL:    *cp++ = ESCAPE;         break;
+                        break;
+                    case 'S':
+                        *cp++ = SP;
+                        inptr++;
+                        break;
+                    case 'N':
+                        *cp++ = NL;
+                        inptr++;
+                        break;
+                    case 'T':
+                        *cp++ = HT;
+                        inptr++;
+                        break;
+                    case 'B':
+                        *cp++ = BS;
+                        inptr++;
+                        break;
+                    case 'R':
+                        *cp++ = CR;
+                        inptr++;
+                        break;
+                    case '0':{
+                                int i = 3;
+                                *cp = 0;
+                                do {
+                                        if (*++inptr < '0' || *inptr > '7')
+                                                break;
+
+                                        *cp = (*cp << 3) | (*inptr - '0');
+                                } while (--i != 0);
+                                cp++;
+                        } break;
+                    default:    *cp++ = *inptr++;       break;
+                }
+        }
+  }
+  if (size >= subsz) return(NULL);
+
+  *cp = EOS;
+  return(sub);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/matchs.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/matchs.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,88 @@
+/*      matchs.c        */
+#include <stdio.h>
+#include "tools.h"
+
+/* Compares line and pattern.  Line is a character string while pat
+ * is a pattern template made by getpat().
+ * Returns:
+ *      1. A zero if no match was found.
+ *
+ *      2. A pointer to the last character satisfing the match
+ *         if ret_endp is non-zero.
+ *
+ *      3. A pointer to the beginning of the matched string if
+ *         ret_endp is zero.
+ *
+ * e.g.:
+ *
+ *      matchs ("1234567890", getpat("4[0-9]*7), 0);
+ * will return a pointer to the '4', while:
+ *
+ *      matchs ("1234567890", getpat("4[0-9]*7), 1);
+ * will return a pointer to the '7'.
+ */
+char *
+ matchs(line, pat, ret_endp)
+char *line;
+TOKEN *pat;
+int ret_endp;
+{
+
+  char *rval, *bptr;
+  char *line2;
+  TOKEN *pat2;
+  char c;
+  short ok;
+
+  bptr = line;
+
+  while (*line) {
+
+        if (pat && pat->tok == LITCHAR) {
+                while (*line) {
+                        pat2 = pat;
+                        line2 = line;
+                        if (*line2 != pat2->lchar) {
+                                c = pat2->lchar;
+                                while (*line2 && *line2 != c) ++line2;
+                                line = line2;
+                                if (*line2 == '\0') break;
+                        }
+                        ok = 1;
+                        ++line2;
+                        pat2 = pat2->next;
+                        while (pat2 && pat2->tok == LITCHAR) {
+                                if (*line2 != pat2->lchar) {
+                                        ok = 0;
+                                        break;
+                                }
+                                ++line2;
+                                pat2 = pat2->next;
+                        }
+                        if (!pat2) {
+                                if (ret_endp)
+                                        return(--line2);
+                                else
+                                        return(line);
+                        } else if (ok)
+                                break;
+                        ++line;
+                }
+                if (*line == '\0') return(0);
+        } else {
+                line2 = line;
+                pat2 = pat;
+        }
+        if ((rval = amatch(line2, pat2, bptr)) == 0) {
+                if (pat && pat->tok == BOL) break;
+                line++;
+        } else {
+                if (rval > bptr && rval > line)
+                        rval--; /* point to last char matched */
+                rval = ret_endp ? rval : line;
+                break;
+        }
+  }
+  return(rval);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/move.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/move.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,60 @@
+/*      move.c  */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+int move(num)
+int num;
+{
+  LINE *k0, *k1, *k2, *k3;
+
+  if (line1 <= 0 || line2 < line1 || (line1 <= num && num <= line2))
+        return(ERR);
+  k0 = getptr(prevln(line1));
+  k1 = getptr(line1);
+  k2 = getptr(line2);
+  k3 = getptr(nextln(line2));
+
+  relink(k0, k3, k0, k3);
+  lastln -= line2 - line1 + 1;
+
+  if (num > line1) num -= line2 - line1 + 1;
+
+  curln = num + (line2 - line1 + 1);
+
+  k0 = getptr(num);
+  k3 = getptr(nextln(num));
+
+  relink(k0, k1, k2, k3);
+  relink(k2, k3, k0, k1);
+  lastln += line2 - line1 + 1;
+
+  return(1);
+}
+
+int transfer(num)
+int num;
+{
+  int mid, lin, ntrans;
+
+  if (line1 <= 0 || line1 > line2) return(ERR);
+
+  mid = num < line2 ? num : line2;
+
+  curln = num;
+  ntrans = 0;
+
+  for (lin = line1; lin <= mid; lin++) {
+        ins(gettxt(lin));
+        ntrans++;
+  }
+  lin += ntrans;
+  line2 += ntrans;
+
+  for (; lin <= line2; lin += 2) {
+        ins(gettxt(lin));
+        line2++;
+  }
+  return(1);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/omatch.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/omatch.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,53 @@
+/*      omatch.c        */
+#include <stdio.h>
+#include "tools.h"
+
+/* Match one pattern element, pointed at by pat, with the character at
+ * **linp.  Return non-zero on match.  Otherwise, return 0.  *Linp is
+ * advanced to skip over the matched character; it is not advanced on
+ * failure.  The amount of advance is 0 for patterns that match null
+ * strings, 1 otherwise.  "boln" should point at the position that will
+ * match a BOL token.
+ */
+int omatch(linp, pat, boln)
+char **linp;
+TOKEN *pat;
+char *boln;
+{
+
+  register int advance;
+
+  advance = -1;
+
+  if (**linp) {
+        switch (pat->tok) {
+            case LITCHAR:
+                if (**linp == pat->lchar) advance = 1;
+                break;
+
+            case BOL:
+                if (*linp == boln) advance = 0;
+                break;
+
+            case ANY:
+                if (**linp != '\n') advance = 1;
+                break;
+
+            case EOL:
+                if (**linp == '\n') advance = 0;
+                break;
+
+            case CCL:
+                if (testbit(**linp, pat->bitmap)) advance = 1;
+                break;
+
+            case NCCL:
+                if (!testbit(**linp, pat->bitmap)) advance = 1;
+                break;
+        }
+  }
+  if (advance >= 0) *linp += advance;
+
+  return(++advance);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/optpat.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/optpat.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,26 @@
+/*      optpat.c        */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+TOKEN *oldpat;
+
+TOKEN *
+ optpat()
+{
+  char delim, str[MAXPAT], *cp;
+
+  delim = *inptr++;
+  cp = str;
+  while (*inptr != delim && *inptr != NL) {
+        if (*inptr == ESCAPE && inptr[1] != NL) *cp++ = *inptr++;
+        *cp++ = *inptr++;
+  }
+
+  *cp = EOS;
+  if (*str == EOS) return(oldpat);
+  if (oldpat) unmakepat(oldpat);
+  oldpat = getpat(str);
+  return(oldpat);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/set.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/set.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,56 @@
+/*      set.c   */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+struct tbl {
+  char *t_str;
+  int *t_ptr;
+  int t_val;
+} *t, tbl[] = {
+
+  "number", &nflg, TRUE,
+  "nonumber", &nflg, FALSE,
+  "list", &lflg, TRUE,
+  "nolist", &lflg, FALSE,
+  "eightbit", &eightbit, TRUE,
+  "noeightbit", &eightbit, FALSE,
+  0
+};
+
+int set()
+{
+  char word[16];
+  int i;
+
+  inptr++;
+  if (*inptr != 't') {
+        if (*inptr != SP && *inptr != HT && *inptr != NL) return(ERR);
+  } else
+        inptr++;
+
+  if (*inptr == NL) return(show());
+  /* Skip white space */
+  while (*inptr == SP || *inptr == HT) inptr++;
+
+  for (i = 0; *inptr != SP && *inptr != HT && *inptr != NL;)
+        word[i++] = *inptr++;
+  word[i] = EOS;
+  for (t = tbl; t->t_str; t++) {
+        if (strcmp(word, t->t_str) == 0) {
+                *t->t_ptr = t->t_val;
+                return(0);
+        }
+  }
+  return(0);
+}
+
+int show()
+{
+  extern int version;
+
+  printf("ed version %d.%d\n", version / 100, version % 100);
+  printf("number %s, list %s\n", nflg ? "ON" : "OFF", lflg ? "ON" : "OFF");
+  return(0);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/setbuf.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/setbuf.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,23 @@
+/*      setbuf.c        */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+relink(a, x, y, b)
+LINE *a, *x, *y, *b;
+{
+  x->l_prev = a;
+  y->l_next = b;
+}
+
+clrbuf()
+{
+  del(1, lastln);
+}
+
+set_buf()
+{
+  relink(&line0, &line0, &line0, &line0);
+  curln = lastln = 0;
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/subst.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/subst.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,53 @@
+/*      subst.c */
+#include <stdio.h>
+#include "tools.h"
+#include "ed.h"
+
+int subst(pat, sub, gflg, pflag)
+TOKEN *pat;
+char *sub;
+int gflg, pflag;
+{
+  int lin, chngd, nchngd;
+  char *txtptr, *txt;
+  char *lastm, *m, *new, buf[MAXLINE];
+
+  if (line1 <= 0) return(ERR);
+  nchngd = 0;                   /* reset count of lines changed */
+  for (lin = line1; lin <= line2; lin++) {
+        txt = txtptr = gettxt(lin);
+        new = buf;
+        chngd = 0;
+        lastm = NULL;
+        while (*txtptr) {
+                if (gflg || !chngd)
+                        m = amatch(txtptr, pat, txt);
+                else
+                        m = NULL;
+                if (m != NULL && lastm != m) {
+                        chngd++;
+                        new = catsub(txtptr, m, sub, new,
+                                     buf + MAXLINE);
+                        lastm = m;
+                }
+                if (m == NULL || m == txtptr) {
+                        *new++ = *txtptr++;
+                } else {
+                        txtptr = m;
+                }
+        }
+        if (chngd) {
+                if (new >= buf + MAXLINE) return(ERR);
+                *new++ = EOS;
+                del(lin, lin);
+                ins(buf);
+                nchngd++;
+                if (pflag) doprnt(curln, curln);
+        }
+  }
+  if (nchngd == 0 && !gflg) {
+        return(ERR);
+  }
+  return(nchngd);
+}
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/tools.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/tools.h	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,97 @@
+/*      tools.h */
+/*
+ *      #defines for non-printing ASCII characters
+ */
+
+#define NUL     0x00            /* ^@ */
+#define EOS     0x00            /* end of string */
+#define SOH     0x01            /* ^A */
+#define STX     0x02            /* ^B */
+#define ETX     0x03            /* ^C */
+#define EOT     0x04            /* ^D */
+#define ENQ     0x05            /* ^E */
+#define ACK     0x06            /* ^F */
+#define BEL     0x07            /* ^G */
+#define BS      0x08            /* ^H */
+#define HT      0x09            /* ^I */
+#define LF      0x0a            /* ^J */
+#define NL      '\n'
+#define VT      0x0b            /* ^K */
+#define FF      0x0c            /* ^L */
+#define CR      0x0d            /* ^M */
+#define SO      0x0e            /* ^N */
+#define SI      0x0f            /* ^O */
+#define DLE     0x10            /* ^P */
+#define DC1     0x11            /* ^Q */
+#define DC2     0x12            /* ^R */
+#define DC3     0x13            /* ^S */
+#define DC4     0x14            /* ^T */
+#define NAK     0x15            /* ^U */
+#define SYN     0x16            /* ^V */
+#define ETB     0x17            /* ^W */
+#define CAN     0x18            /* ^X */
+#define EM      0x19            /* ^Y */
+#define SUB     0x1a            /* ^Z */
+#define ESC     0x1b            /* ^[ */
+#define FS      0x1c            /* ^\ */
+#define GS      0x1d            /* ^] */
+#define RS      0x1e            /* ^^ */
+#define US      0x1f            /* ^_ */
+#define SP      0x20            /* space */
+#define DEL     0x7f            /* DEL */
+
+#define TRUE    1
+#define FALSE   0
+#define ERR     -2
+
+/*      Definitions of meta-characters used in pattern matching
+ *      routines.  LITCHAR & NCCL are only used as token identifiers;
+ *      all the others are also both token identifier and actual symbol
+ *      used in the regular expression.
+ */
+
+#define BOL     '^'
+#define EOL     '$'
+#define ANY     '.'
+#define LITCHAR 'L'
+#define ESCAPE  '\\'
+#define CCL     '['             /* Character class: [...] */
+#define CCLEND  ']'
+#define NEGATE  '~'
+#define NCCL    '!'             /* Negative character class [^...] */
+#define CLOSURE '*'
+#define OR_SYM  '|'
+#define DITTO   '&'
+#define OPEN    '('
+#define CLOSE   ')'
+
+/* Largest permitted size for an expanded character class.  (i.e. the class
+ * [a-z] will expand into 26 symbols; [a-z0-9] will expand into 36.)
+ */
+#define CLS_SIZE        128
+
+/*
+ *      Tokens are used to hold pattern templates. (see makepat())
+ */
+typedef char BITMAP;
+
+typedef struct token {
+  char tok;
+  char lchar;
+  BITMAP *bitmap;
+  struct token *next;
+} TOKEN;
+
+#define TOKSIZE sizeof (TOKEN)
+
+/*
+ *      An absolute maximun for strings.
+ */
+
+#define MAXSTR  132             /* Maximum numbers of characters in a line */
+
+/* Macros */
+#define max(a,b)        ((a>b)?a:b)
+#define min(a,b)        ((a<b)?a:b)
+#define toupper(c)      (c>='a'&&c<='z'?c-32:c)
+
diff -r 57b5e715a417 -r bef1844de0dc 3rdparty/packages/ed/unmkpat.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/3rdparty/packages/ed/unmkpat.c	Sun Feb 23 21:11:37 2003 +0000
@@ -0,0 +1,26 @@
+/*      unmkpat.c       */
+#include <stdio.h>
+#include "tools.h"
+
+/* Free up the memory usde for token string */
+unmakepat(head)
+TOKEN *head;
+{
+
+  register TOKEN *old_head;
+
+  while (head) {
+        switch (head->tok) {
+            case CCL:
+            case NCCL:
+                free(head->bitmap);
+                /* Fall through to default */
+
+            default:
+                old_head = head;
+                head = head->next;
+                free((char *) old_head);
+                break;
+        }
+  }
+}