home *** CD-ROM | disk | FTP | other *** search
/ Garbo / Garbo.cdr / pc / unix / ed3.lzh / ED.C next >
Encoding:
Text File  |  1988-08-27  |  43.2 KB  |  2,220 lines
  1. /*
  2.  *  ed - standard editor
  3.  *  ~~
  4.  *    Authors: Brian Beattie, Kees Bot, and others
  5.  *
  6.  * Copyright 1987 Brian Beattie Rights Reserved.
  7.  * Permission to copy or distribute granted under the following conditions:
  8.  * 1). No charge may be made other than reasonable charges for reproduction.
  9.  * 2). This notice must remain intact.
  10.  * 3). No further restrictions may be added.
  11.  *
  12.  * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  13.  *  TurboC mods and cleanup 8/17/88 RAMontante.
  14.  *  Further information (posting headers, etc.) at end of file.
  15.  * _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
  16.  */
  17.  
  18. int    version = 3;    /* used only in the "set" function, for i.d. */
  19.  
  20. #include <stdio.h>
  21.  
  22. #ifdef __TURBOC__
  23. #include <stdlib.h>
  24. #include <signal.h>
  25. #include <string.h>
  26. #include <io.h>
  27.  
  28. #define    _cleanup()    ;
  29.  
  30. #endif  /* ifdef __TURBOC__  */
  31.  
  32.  
  33. /*
  34.  *    #defines for non-printing ASCII characters
  35.  */
  36. #define NUL    0x00    /* ^@ */
  37. #define EOS    0x00    /* end of string */
  38. #define SOH    0x01    /* ^A */
  39. #define STX    0x02    /* ^B */
  40. #define ETX    0x03    /* ^C */
  41. #define EOT    0x04    /* ^D */
  42. #define ENQ    0x05    /* ^E */
  43. #define ACK    0x06    /* ^F */
  44. #define BEL    0x07    /* ^G */
  45. #define BS    0x08    /* ^H */
  46. #define HT    0x09    /* ^I */
  47. #define LF    0x0a    /* ^J */
  48. #define NL    '\n'
  49. #define VT    0x0b    /* ^K */
  50. #define FF    0x0c    /* ^L */
  51. #define CR    0x0d    /* ^M */
  52. #define SO    0x0e    /* ^N */
  53. #define SI    0x0f    /* ^O */
  54. #define DLE    0x10    /* ^P */
  55. #define DC1    0x11    /* ^Q */
  56. #define DC2    0x12    /* ^R */
  57. #define DC3    0x13    /* ^S */
  58. #define DC4    0x14    /* ^T */
  59. #define NAK    0x15    /* ^U */
  60. #define SYN    0x16    /* ^V */
  61. #define ETB    0x17    /* ^W */
  62. #define CAN    0x18    /* ^X */
  63. #define EM    0x19    /* ^Y */
  64. #define SUB    0x1a    /* ^Z */
  65. #define ESC    0x1b    /* ^[ */
  66. #define FS    0x1c    /* ^\ */
  67. #define GS    0x1d    /* ^] */
  68. #define RS    0x1e    /* ^^ */
  69. #define US    0x1f    /* ^_ */
  70. #define SP    0x20    /* space */
  71. #define DEL    0x7f    /* DEL*/
  72.  
  73.  
  74. /*    Definitions of meta-characters used in pattern matching
  75.  *    routines.  LITCHAR & NCCL are only used as token identifiers;
  76.  *    all the others are also both token identifier and actual symbol
  77.  *    used in the regular expression.
  78.  */
  79. #define BOL    '^'
  80. #define EOL    '$'
  81. #define ANY    '.'
  82. #define LITCHAR    'L'
  83. #define    ESCAPE    '\\'
  84. #define CCL    '['    /* Character class: [...] */
  85. #define CCLEND    ']'
  86. #define NEGATE    '~'
  87. #define NCCL    '!'    /* Negative character class [^...] */
  88. #define CLOSURE    '*'
  89. #define OR_SYM    '|'
  90. #define DITTO    '&'
  91. #define OPEN    '('
  92. #define CLOSE    ')'
  93.  
  94.  
  95. /* Largest permitted size for an expanded character class.  (i.e. the class
  96.  * [a-z] will expand into 26 symbols; [a-z0-9] will expand into 36.)
  97.  */
  98. #define CLS_SIZE    128
  99.  
  100.  
  101. #define TRUE    1
  102. #define FALSE    0
  103. #define ERR        -2
  104. #define FATAL        (ERR-1)
  105. #define CHANGED        (ERR-2)
  106. #define SET_FAIL    (ERR-3)
  107. #define SUB_FAIL    (ERR-4)
  108.  
  109.  
  110. #define    BUFFER_SIZE    2048    /* stream-buffer size:  == 1 hd cluster */
  111.  
  112. #define LINFREE    1    /* entry not in use */
  113. #define LGLOB    2       /* line marked global */
  114.  
  115. #define MAXLINE    512    /* max number of chars per line */
  116. #define MAXPAT    256    /* max number of chars per replacement pattern */
  117. #define MAXFNAME 256    /* max file name size */
  118.  
  119.  
  120. /**  Global variables  **/
  121.  
  122. /*  Tokens are used to hold pattern templates. (see makepat())  */
  123.  
  124. typedef    char    BITMAP;
  125. typedef struct token {
  126.     char        tok;
  127.     char        lchar;
  128.     BITMAP        *bitmap;
  129.     struct token    *next;
  130. } TOKEN;
  131.  
  132. #define TOKSIZE sizeof (TOKEN)
  133.  
  134.  
  135. struct    line {
  136.     int        l_stat;        /* empty, mark */
  137.     struct line    *l_prev;
  138.     struct line    *l_next;
  139.     char        l_buff[1];
  140. };
  141. typedef struct line    LINE;
  142.  
  143.  
  144. int    diag = 1;        /* diagnostic-output? flag */
  145. char    *paropen[9];
  146. char    *parclose[9];
  147. int    between, parnum;
  148. int    truncflg = 1;    /* truncate long line flag */
  149. int    eightbit = 1;    /* save eighth bit */
  150. int    nonascii;    /* count of non-ascii chars read */
  151. int    nullchar;    /* count of null chars read */
  152. int    truncated;    /* count of lines truncated */
  153. char    fname[MAXFNAME];
  154. int    fchanged;    /* file-changed? flag */
  155. int    nofname;
  156. int    mark['z'-'a'+1];
  157. TOKEN    *oldpat;
  158.  
  159. LINE    Line0;
  160. int    CurLn = 0;
  161. int    LastLn = 0;
  162. char    inlin[MAXLINE];
  163. int    pflag;
  164. int    Line1, Line2, nlines;
  165. int    nflg;        /* print line number flag */
  166. int    lflg;        /* print line in verbose mode */
  167. int    pflg;        /* print current line after each command */
  168. char    *inptr;        /* tty input buffer */
  169.  
  170. struct tbl {
  171.     char    *t_str;
  172.     int    *t_ptr;
  173.     int    t_val;
  174. } *t, tbl[] = {
  175.     "number",    &nflg,        TRUE,
  176.     "nonumber",    &nflg,        FALSE,
  177.     "list",        &lflg,        TRUE,
  178.     "nolist",    &lflg,        FALSE,
  179.     "eightbit",    &eightbit,    TRUE,
  180.     "noeightbit",    &eightbit,    FALSE,
  181.     0
  182. };
  183.  
  184.  
  185. /*-------------------------------------------------------------------------*/
  186.  
  187. #ifdef __TURBOC__        /*  prototypes (unneeded?)  */
  188.  
  189. void    prntln(char *, int, int);
  190. void    putcntl(char , FILE *);
  191. int    doprnt(int, int);
  192. LINE    *getptr(int);
  193. BITMAP    *makebitmap(unsigned);
  194. void    relink(LINE *, LINE *, LINE *, LINE *);
  195. int    del(int, int);
  196. int    ins(char *);
  197. char    *gettxt(int);
  198. int    append(int, int);
  199. char    *catsub(char *, char *, char *, char *, char *);
  200. char    *matchs(char *, TOKEN *, int);
  201. int    deflt(int, int);
  202. char    *maksub(char *sub, int subsz);
  203. TOKEN    *optpat(void);
  204.  
  205. #else    /* !__TURBOC__ */
  206.  
  207. extern    char    *strcpy();
  208. extern    int    *malloc();
  209. extern    LINE    *getptr();
  210. BITMAP    *makebitmap();
  211. extern    char    *gettxt();
  212. extern    char    *catsub();
  213. extern    char    *matchs();
  214. char    *maksub();
  215. TOKEN    *optpat();
  216.  
  217. #endif  /* __TURBOC__ */
  218.  
  219.  
  220. /*________  Macros  ________________________________________________________*/
  221.  
  222. #ifndef max
  223. #  define max(a,b)    ((a) > (b) ? (a) : (b))
  224. #endif
  225.  
  226. #ifndef min
  227. #  define min(a,b)    ((a) < (b) ? (a) : (b))
  228. #endif
  229.  
  230. #ifndef toupper
  231. #  define toupper(c)    ((c >= 'a' && c <= 'z') ? c-32 : c )
  232. #endif
  233.  
  234. /*  getpat -- Translate arg into a TOKEN string  */
  235. #define    getpat(arg)    makepat((arg), '\000')
  236.  
  237. #define nextln(l)    ((l)+1 > LastLn ? 0 : (l)+1)
  238. #define prevln(l)    ((l)-1 < 0 ? LastLn : (l)-1)
  239.  
  240. #define clrbuf()    del(1, LastLn)
  241.  
  242. #define    Skip_White_Space    {while (*inptr==SP || *inptr==HT) inptr++;}
  243.  
  244.  
  245. /*________  functions  ______________________________________________________*/
  246.  
  247. /*****************************************************************************
  248.  *    BITMAP.C -    makebitmap, setbit, testbit
  249.  *            bit-map manipulation routines.
  250.  *
  251.  *    Copyright (c) Allen I. Holub, all rights reserved.  This program may
  252.  *        for copied for personal, non-profit use only.
  253.  */
  254. BITMAP    *makebitmap( size )
  255. unsigned size;
  256. {
  257.     /*    Make a bit map with "size" bits.  The first entry in
  258.      *    the map is an "unsigned int" representing the maximum
  259.      *    bit.  The map itself is concatenated to this integer.
  260.      *    Return a pointer to a map on success, 0 if there's
  261.      *    not enough memory.
  262.      */
  263.  
  264.     unsigned *map, numbytes;
  265.  
  266.     numbytes = (size >> 3) + ((size & 0x07) ? 1 : 0 );
  267.  
  268. #ifdef DEBUG
  269.     printf("Making a %u bit map (%u bytes required)\n", size, numbytes);
  270. #endif
  271.  
  272.     if( map = (unsigned *) malloc( numbytes + sizeof(unsigned) ))
  273.         *map = size;
  274.  
  275.     return ((BITMAP *)map);
  276. }
  277.  
  278. setbit( c, map, val )
  279. unsigned    c, val;
  280. char        *map;
  281. {
  282.     /*    Set bit c in the map to val.
  283.      *    If c > map-size, 0 is returned, else 1 is returned.
  284.      */
  285.  
  286.     if( c >= *(unsigned *)map )    /* if c >= map size */
  287.         return 0;
  288.  
  289.     map += sizeof(unsigned);    /* skip past size */
  290.  
  291.     if( val )
  292.         map[c >> 3] |= 1 << (c & 0x07);
  293.     else
  294.         map[c >> 3] &= ~(1 << (c & 0x07));
  295.  
  296.     return( 1 );
  297. }
  298.  
  299. testbit( c, map )
  300. unsigned    c;
  301. char        *map;
  302. {
  303.     /*    Return 1 if the bit corresponding to c in map is set.
  304.      *    0 if it is not.
  305.      */
  306.  
  307.     if( c >= *(unsigned *)map )
  308.         return 0;
  309.  
  310.     map += sizeof(unsigned);
  311.  
  312.     return(map[ c >> 3 ] & (1 << (c & 0x07)));
  313. }
  314. /*********  end of BITMAP.C  ************************************************/
  315.  
  316.  
  317. /*    omatch.c
  318.  *
  319.  * Match one pattern element, pointed at by pat, with the character at
  320.  * **linp.  Return non-zero on match.  Otherwise, return 0.  *Linp is
  321.  * advanced to skip over the matched character; it is not advanced on
  322.  * failure.  The amount of advance is 0 for patterns that match null
  323.  * strings, 1 otherwise.  "boln" should point at the position that will
  324.  * match a BOL token.
  325.  */
  326. omatch(linp, pat, boln)
  327. char    **linp;
  328. TOKEN    *pat;
  329. char    *boln;
  330. {
  331.     register int    advance;
  332.  
  333.     advance = -1;
  334.     if (**linp) {
  335.         switch (pat->tok) {
  336.         case LITCHAR:
  337.             if (**linp == pat->lchar)
  338.                 advance = 1;
  339.             break;
  340.  
  341.         case BOL:
  342.             if (*linp == boln)    /* Replaced (*linp = boln */
  343.                 advance = 0;
  344.             break;
  345.  
  346.         case ANY:
  347.             if (**linp != '\n')
  348.                 advance = 1;
  349.             break;
  350.  
  351.         case EOL:
  352.             if (**linp == '\n')
  353.                 advance = 0;
  354.             break;
  355.  
  356.         case CCL:
  357.             if( testbit( **linp, pat->bitmap))
  358.                 advance = 1;
  359.             break;
  360.  
  361.         case NCCL:
  362.             if (!testbit (**linp, pat->bitmap))
  363.                 advance = 1;
  364.             break;
  365.         }
  366.     }
  367.     if (advance >= 0)
  368.         *linp += advance;
  369.  
  370.     return (++advance);
  371. }
  372.  
  373.  
  374. static char *match(lin, pat, boln)
  375. char    *lin;
  376. TOKEN    *pat;
  377. char    *boln;
  378. {
  379.     register char    *bocl, *rval, *strstart;
  380.  
  381.     if(pat == 0)
  382.         return 0;
  383.  
  384.     strstart = lin;
  385.     while(pat) {
  386.         if(pat->tok == CLOSURE && pat->next) {
  387.  
  388.             /* Process a closure:
  389.              * first skip over the closure token to the
  390.              * object to be repeated.  This object can be
  391.              * a character class.
  392.              */
  393.             pat = pat->next;
  394.  
  395.             /* Now match as many occurrences of the
  396.              * closure pattern as possible.
  397.              */
  398.             bocl = lin;
  399.             while( *lin && omatch(&lin, pat))
  400.                 ;
  401.  
  402.             /* 'Lin' now points to the character that
  403.              * made us fail.  Now go on to process the
  404.              * rest of the string.  A problem here is
  405.              * a character following the closure which
  406.              * could have been in the closure.
  407.              * For example, in the pattern "[a-z]*t" (which
  408.              * matches any lower-case word ending in a t),
  409.              * the final 't' will be sucked up in the while
  410.              * loop.  So, if the match fails, we back up a
  411.              * notch and try to match the rest of the
  412.              * string again, repeating this process
  413.              * recursively until we get back to the
  414.              * beginning of the closure.  The recursion
  415.              * goes, at most two levels deep.
  416.              */
  417.             if(pat = pat->next)
  418.             {
  419.                 int savbtwn=between;
  420.                 int savprnm=parnum;
  421.  
  422.                 while(bocl <= lin) {
  423.                     if (rval = match(lin, pat, boln)) {
  424.                         return(rval);    /* success */
  425.                     } else {
  426.                         --lin;
  427.                         between=savbtwn;
  428.                         parnum=savprnm;
  429.                     }
  430.                 }
  431.                 return (0);    /* match failed */
  432.             }
  433.         } else
  434.         if (pat->tok == OPEN) {
  435.             if (between || parnum>=9)
  436.                 return 0;
  437.             paropen[parnum] = lin;
  438.             between = 1;
  439.             pat = pat->next;
  440.         } else
  441.         if (pat->tok == CLOSE) {
  442.             if (!between)
  443.                 return 0;
  444.             parclose[parnum++] = lin;
  445.             between = 0;
  446.             pat = pat->next;
  447.         } else
  448.         if (omatch(&lin, pat, boln)) {
  449.             pat = pat->next;
  450.         } else {
  451.             return (0);
  452.         }
  453.     }
  454.     /* Note that omatch() advances lin to point at the next
  455.      * character to be matched.  Consequently, when we reach
  456.      * the end of the template, lin will be pointing at the
  457.      * character following the last character matched.  The
  458.      * exceptions are templates containing only a BOLN or EOLN
  459.      * token.  In these cases omatch doesn't advance.
  460.      *
  461.      * A philosophical point should be mentioned here.  Is $
  462.      * a position or a character? (i.e. does $ mean the EOL
  463.      * character itself or does it mean the character at the end
  464.      * of the line.)  I decided here to make it mean the former,
  465.      * in order to make the behavior of match() consistent.  If
  466.      * you give match the pattern ^$ (match all lines consisting
  467.      * only of an end of line) then, since something has to be
  468.      * returned, a pointer to the end of line character itself is
  469.      * returned.
  470.      */
  471.  
  472.     return ((char *)max(strstart , lin));
  473. }
  474.  
  475.  
  476. /*  amatch.c
  477.  *
  478.  *    Scans throught the pattern template looking for a match
  479.  *    with lin.  Each element of lin is compared with the template
  480.  *    until either a mis-match is found or the end of the template
  481.  *    is reached.  In the former case a 0 is returned; in the latter,
  482.  *    a pointer into lin (pointing to the character following the
  483.  *    matched pattern) is returned.
  484.  *
  485.  *    "lin"    is a pointer to the line being searched.
  486.  *    "pat"    is a pointer to a template made by makepat().
  487.  *    "boln"    is a pointer into "lin" which points at the
  488.  *            character at the beginning of the line.
  489.  */
  490. char *amatch(lin, pat, boln)
  491. char    *lin;
  492. TOKEN    *pat;
  493. char    *boln;
  494. {
  495.     between = parnum = 0;
  496.     lin = match(lin, pat, boln);
  497.  
  498.     if (between)
  499.         return 0;
  500.  
  501.     while (parnum<9) {
  502.         paropen[parnum] = parclose[parnum] = "";
  503.         parnum++;
  504.     }
  505.     return lin;
  506. }
  507.  
  508.  
  509. /*    append.c    */
  510.  
  511. append(line, glob)
  512. int    line, glob;
  513. {
  514.     int    stat;
  515.     char    lin[MAXLINE];
  516.  
  517.     if(glob)
  518.         return(ERR);
  519.     CurLn = line;
  520.     for (;;) {
  521.         if(nflg)
  522.             printf("%6d. ",CurLn+1);
  523.  
  524.         if(fgets(lin, MAXLINE, stdin) == NULL)
  525.             return( EOF );
  526.         if(lin[0] == '.' && lin[1] == '\n')
  527.             return(0);
  528.         stat = ins(lin);
  529.         if(stat < 0)
  530.             return( ERR );
  531.  
  532.     }
  533. }
  534.  
  535.  
  536. /*    catsub.c    */
  537.  
  538. char *catsub(from, to, sub, new, newend)
  539. char    *from, *to, *sub, *new, *newend;
  540. {
  541.     char    *cp, *cp2;
  542.  
  543.     for(cp = new; *sub != EOS && cp < newend;) {
  544.         if(*sub == DITTO)
  545.             for(cp2 = from; cp2 < to;) {                *cp++ = *cp2++;
  546.                 if(cp >= newend)
  547.                     break;
  548.             }
  549.         else
  550.         if (*sub == ESCAPE) {
  551.             sub++;
  552.             if ('1' <= *sub && *sub <= '9') {
  553.                 char *parcl = parclose[*sub - '1'];
  554.  
  555.                 for (cp2 = paropen[*sub - '1']; cp2 < parcl;) {
  556.                     *cp++ = *cp2++;
  557.                     if (cp >= newend)
  558.                         break;
  559.                 }
  560.             } else
  561.                 *cp++ = *sub;
  562.         } else
  563.             *cp++ = *sub;
  564.  
  565.         sub++;
  566.     }
  567.  
  568.     return(cp);
  569. }
  570.  
  571.  
  572. /*    ckglob.c    */
  573.  
  574. ckglob()
  575. {
  576.     TOKEN    *glbpat;
  577.     char    c, delim, *lin;
  578.     int    num;
  579.     LINE    *ptr;
  580.  
  581.     c = *inptr;
  582.  
  583.     if(c != 'g' && c != 'v')
  584.         return(0);
  585.     if (deflt(1, LastLn) < 0)
  586.         return(ERR);
  587.  
  588.     delim = *++inptr;
  589.     if(delim <= ' ')
  590.         return(ERR);
  591.  
  592.     glbpat = optpat();
  593.     if(*inptr == delim)
  594.         inptr++;
  595.     for (num=1; num<=LastLn; num++) {
  596.         ptr = getptr(num);
  597.         ptr->l_stat &= ~LGLOB;
  598.         if (Line1 <= num && num <= Line2) {
  599.             lin = gettxt(num);
  600.             if(matchs(lin, glbpat, 0)) {
  601.                 if (c=='g') ptr->l_stat |= LGLOB;
  602.             } else {
  603.                 if (c=='v') ptr->l_stat |= LGLOB;
  604.             }
  605.         }
  606.     }
  607.     return(1);
  608. }
  609.  
  610.  
  611. /*  deflt.c
  612.  *    Set Line1 & Line2 (the command-range delimiters) if the file is
  613.  *    empty; Test whether they have valid values.
  614.  */
  615.  
  616. int deflt(def1, def2)
  617. int    def1, def2;
  618. {
  619.     if(nlines == 0) {
  620.         Line1 = def1;
  621.         Line2 = def2;
  622.     }
  623.     return ( (Line1>Line2 || Line1<=0) ? ERR : 0 );
  624. }
  625.  
  626.  
  627. /*    del.c    */
  628.  
  629. /* One of the calls to this function tests its return value for an error
  630.  * condition.  But del doesn't return any error value, and it isn't obvious
  631.  * to me what errors might be detectable/reportable.  To silence a warning
  632.  * message, I've added a constant return statement. -- RAM
  633.  */
  634.  
  635. del(from, to)
  636. int    from, to;
  637. {
  638.     LINE    *first, *last, *next, *tmp;
  639.  
  640.     if(from < 1)
  641.         from = 1;
  642.     first = getptr(prevln(from));
  643.     last = getptr(nextln(to));
  644.     next = first->l_next;
  645.     while(next != last && next != &Line0) {
  646.         tmp = next->l_next;
  647.         free(next);
  648.         next = tmp;
  649.     }
  650.     relink(first, last, first, last);
  651.     LastLn -= (to - from)+1;
  652.     CurLn = prevln(from);
  653.     return(0);
  654. }
  655.  
  656.  
  657. int dolst(line1, line2)
  658. int line1, line2;
  659. {
  660.     int oldlflg=lflg, p;
  661.  
  662.     lflg = 1;
  663.     p = doprnt(line1, line2);
  664.     lflg = oldlflg;
  665.     return p;
  666. }
  667.  
  668.  
  669. /*    esc.c
  670.  * Map escape sequences into their equivalent symbols.  Returns the
  671.  * correct ASCII character.  If no escape prefix is present then s
  672.  * is untouched and *s is returned, otherwise **s is advanced to point
  673.  * at the escaped character and the translated character is returned.
  674.  */
  675. esc(s)
  676. char    **s;
  677. {
  678.     register int    rval;
  679.  
  680.     if (**s != ESCAPE) {
  681.         rval = **s;
  682.     } else {
  683.         (*s)++;
  684.         switch(toupper(**s)) {
  685.         case '\000':
  686.             rval = ESCAPE;    break;
  687.         case 'S':
  688.             rval = ' ';    break;
  689.         case 'N':
  690.             rval = '\n';    break;
  691.         case 'T':
  692.             rval = '\t';    break;
  693.         case 'B':
  694.             rval = '\b';    break;
  695.         case 'R':
  696.             rval = '\r';    break;
  697.         default:
  698.             rval = **s;    break;
  699.         }
  700.     }
  701.     return (rval);
  702. }
  703.  
  704.  
  705. /*  dodash.c
  706.  *    Expand the set pointed to by *src into dest.
  707.  *    Stop at delim.  Return 0 on error or size of
  708.  *    character class on success.  Update *src to
  709.  *    point at delim.  A set can have one element
  710.  *    {x} or several elements ( {abcdefghijklmnopqrstuvwxyz}
  711.  *    and {a-z} are equivalent ).  Note that the dash
  712.  *    notation is expanded as sequential numbers.
  713.  *    This means (since we are using the ASCII character
  714.  *    set) that a-Z will contain the entire alphabet
  715.  *    plus the symbols: [\]^_`.  The maximum number of
  716.  *    characters in a character class is defined by maxccl.
  717.  */
  718. char *dodash(delim, src, map)
  719. int    delim;
  720. char    *src, *map;
  721. {
  722.  
  723.     register int    first,    last;
  724.     char        *start;
  725.  
  726.     start = src;
  727.  
  728.     while( *src && *src != delim ) {
  729.         if( *src != '-')
  730.             setbit( esc( &src ), map, 1 );
  731.  
  732.         else
  733.         if( src == start || *(src + 1) == delim )
  734.             setbit( '-', map, 1 );
  735.         else {
  736.             src++;
  737.             if( *src < *(src - 2)) {
  738.                 first = *src;
  739.                 last = *(src - 2);
  740.             } else {
  741.                 first = *(src - 2);
  742.                 last = *src;
  743.             }
  744.             while( ++first <= last )
  745.                 setbit( first, map, 1);
  746.         }
  747.         src++;
  748.     }
  749.     return( src );
  750. }
  751.  
  752.  
  753. /*    doprnt.c    */
  754.  
  755. int doprnt(from, to)
  756. int    from, to;
  757. {
  758.     int    i;
  759.  
  760.     from = (from < 1) ? 1 : from;
  761.     to = (to > LastLn) ? LastLn : to;
  762.  
  763.     if(to != 0) {
  764.         for(i = from; i <= to; i++)
  765.             prntln(gettxt(i), lflg, (nflg ? i : 0));
  766.         CurLn = to;
  767.     }
  768.  
  769.     return(0);
  770. }
  771.  
  772.  
  773. void prntln(str, vflg, lin)
  774. char    *str;
  775. int    vflg, lin;
  776. {
  777.     if(lin)
  778.         printf("%7d ",lin);
  779.     while(*str && *str != NL) {
  780.         if(*str < ' ' || *str >= 0x7f) {
  781.             switch(*str) {
  782.             case '\t':
  783.                 if(vflg)
  784.                     putcntl(*str, stdout);
  785.                 else
  786.                     putc(*str, stdout);
  787.                 break;
  788.  
  789.             case DEL:
  790.                 putc('^', stdout);
  791.                 putc('?', stdout);
  792.                 break;
  793.  
  794.             default:
  795.                 putcntl(*str, stdout);
  796.                 break;
  797.             }
  798.         } else
  799.             putc(*str, stdout);
  800.         str++;
  801.     }
  802.     if(vflg)
  803.         putchar('$');
  804.     putchar('\n');
  805. }
  806.  
  807.  
  808. void putcntl(c, stream)
  809. char    c;
  810. FILE    *stream;
  811. {
  812.     putc('^', stream);
  813.     putc((c&31)|'@', stream);
  814. }
  815.  
  816.  
  817. /*    egets.c    */
  818.  
  819. egets(str,size,stream)
  820. char    *str;
  821. int    size;
  822. FILE    *stream;
  823. {
  824.     int    c, count;
  825.     char    *cp;
  826.  
  827.     for(count = 0, cp = str; size > count;) {
  828.         c = getc(stream);
  829.         if(c == EOF) {
  830.             *cp++ = '\n';
  831.             *cp = EOS;
  832.             if(count)
  833.                 puts("[Incomplete last line]");
  834.             return(count);
  835.         }
  836.         if(c == NL) {
  837.             *cp++ = c;
  838.             *cp = EOS;
  839.             return(++count);
  840.         }
  841.         if(c > 127) {
  842.             if(!eightbit)        /* if not saving eighth bit */
  843.                 c = c&127;    /* strip eigth bit */
  844.             nonascii++;        /* count it */
  845.         }
  846.         if(c) {
  847.             *cp++ = c;    /* not null, keep it */
  848.             count++;
  849.         } else
  850.             nullchar++;    /* count nulls */
  851.     }
  852.     str[count-1] = EOS;
  853.     if(c != NL) {
  854.         puts("truncating line");
  855.         truncated++;
  856.         while((c = getc(stream)) != EOF)
  857.             if(c == NL)
  858.                 break;
  859.     }
  860.     return(count);
  861. }  /* egets */
  862.  
  863.  
  864. doread(lin, fname)
  865. int    lin;
  866. char    *fname;
  867. {
  868.     FILE    *fp;
  869.     int    err;
  870.     unsigned long    bytes;
  871.     unsigned int    lines;
  872.     static char    str[MAXLINE];
  873.  
  874.     err = 0;
  875.     nonascii = nullchar = truncated = 0;
  876.  
  877.     if (diag) printf("\"%s\" ",fname);
  878.     if( (fp = fopen(fname, "r")) == NULL ) {
  879.         puts(" isn't readable.");
  880.         return( ERR );
  881.     }
  882.     setvbuf(fp, NULL, _IOFBF, BUFFER_SIZE);
  883.     CurLn = lin;
  884.     for(lines = 0, bytes = 0;(err = egets(str,MAXLINE,fp)) > 0;) {
  885.         bytes += strlen(str);
  886.         if(ins(str) < 0) {
  887.             puts("file insert error");
  888.             err++;
  889.             break;
  890.         }
  891.         lines++;
  892.     }
  893.     fclose(fp);
  894.     if(err < 0)
  895.         return(err);
  896.     if (diag) {
  897.         printf("%u lines %u bytes",lines,bytes);
  898.         if(nonascii)
  899.             printf(" [%d non-ascii]",nonascii);
  900.         if(nullchar)
  901.             printf(" [%d nul]",nullchar);
  902.         if(truncated)
  903.             printf(" [%d lines truncated]",truncated);
  904.         putchar('\n');
  905.     }
  906.     return( err );
  907. }  /* doread */
  908.  
  909.  
  910. int dowrite(from, to, fname, apflg)
  911. int    from, to;
  912. char    *fname;
  913. int    apflg;
  914. {
  915.     FILE    *fp;
  916.     int    lin, err;
  917.     unsigned int    lines, bytes;
  918.     char    *str;
  919.     LINE    *lptr;
  920.  
  921.     err = 0;
  922.     lines = bytes = 0;
  923.  
  924.     printf("\"%s\" ",fname);
  925.     if((fp = fopen(fname,(apflg?"a":"w"))) == NULL) {
  926.         puts(" can't be opened for writing!");
  927.         return( ERR );
  928.     }
  929.  
  930.     setvbuf(fp, NULL, _IOFBF, BUFFER_SIZE);
  931.     lptr = getptr(from);
  932.     for(lin = from; lin <= to; lin++) {
  933.         str = lptr->l_buff;
  934.         lines++;
  935.         bytes += strlen(str) + 1;    /* str + '\n' */
  936.         if(fputs(str, fp) == EOF) {
  937.             puts("file write error");
  938.             err++;
  939.             break;
  940.         }
  941.         fputc('\n', fp);
  942.         lptr = lptr->l_next;
  943.     }
  944.     printf("%u lines %u bytes\n",lines,bytes);
  945.     fclose(fp);
  946.     return( err );
  947. }  /* dowrite */
  948.  
  949.  
  950. /*    find.c    */
  951.  
  952. find(pat, dir)
  953. TOKEN    *pat;
  954. int    dir;
  955. {
  956.     int    i, num;
  957.     char    *lin;
  958.  
  959.     num=CurLn;
  960.     for(i=0; i<LastLn; i++) {
  961.         lin = gettxt(num);
  962.         if(matchs(lin, pat, 0)) {
  963.             return(num);
  964.         }
  965.         num = (dir ? nextln(num) : prevln(num));
  966.     }
  967.     return ( ERR );
  968. }
  969.  
  970.  
  971. /*    getfn.c    */
  972.  
  973. char *getfn()
  974. {
  975.     static char    file[256];
  976.     char    *cp;
  977.  
  978.     if(*inptr == NL) {
  979.         nofname=TRUE;
  980.         strcpy(file, fname);
  981.     } else {
  982.         nofname=FALSE;
  983.         Skip_White_Space;
  984.  
  985.         cp = file;
  986.         while(*inptr && *inptr != NL && *inptr != SP && *inptr != HT)
  987.             *cp++ = *inptr++;
  988.         *cp = '\0';
  989.  
  990.         if(strlen(file) == 0) {
  991.             puts("bad file name");
  992.             return( NULL );
  993.         }
  994.     }
  995.  
  996.     if(strlen(file) == 0) {
  997.         puts("no file name");
  998.         return(NULL);
  999.     }
  1000.     return( file );
  1001. }  /* getfn */
  1002.  
  1003.  
  1004. int getnum(first)
  1005. int first;
  1006. {
  1007.     TOKEN    *srchpat;
  1008.     int    num;
  1009.     char    c;
  1010.  
  1011.     Skip_White_Space;
  1012.  
  1013.     if(*inptr >= '0' && *inptr <= '9') {    /* line number */
  1014.         for(num = 0; *inptr >= '0' && *inptr <= '9'; ++inptr) {
  1015.             num = (num * 10) + (*inptr - '0');
  1016.         }
  1017.         return num;
  1018.     }
  1019.  
  1020.     switch(c = *inptr) {
  1021.     case '.':
  1022.         inptr++;
  1023.         return (CurLn);
  1024.  
  1025.     case '$':
  1026.         inptr++;
  1027.         return (LastLn);
  1028.  
  1029.     case '/':
  1030.     case '?':
  1031.         srchpat = optpat();
  1032.         if(*inptr == c)
  1033.             *inptr++;
  1034.         return(find(srchpat,c == '/'?1:0));
  1035.  
  1036.     case '-':
  1037.     case '+':
  1038.         return(first ? CurLn : 1);
  1039.  
  1040.     case '\'':
  1041.         inptr++;
  1042.         if (*inptr < 'a' || *inptr > 'z')
  1043.             return(EOF);
  1044.         return mark[ *inptr++ - 'a' ];
  1045.  
  1046.     default:
  1047.         return ( first ? EOF : 1 );    /* unknown address */
  1048.     }
  1049. }  /* getnum */
  1050.  
  1051.  
  1052. /*  getone.c
  1053.  *    Parse a number (or arithmetic expression) off the command line.
  1054.  */
  1055. #define FIRST 1
  1056. #define NOTFIRST 0
  1057.  
  1058. int getone()
  1059. {
  1060.     int    c, i, num;
  1061.  
  1062.     if((num = getnum(FIRST)) >= 0) {
  1063.         for (;;) {
  1064.             Skip_White_Space;
  1065.             if(*inptr != '+' && *inptr != '-')
  1066.                 break;    /* exit infinite loop */
  1067.  
  1068.                         c = *inptr++;
  1069.             if((i = getnum(NOTFIRST)) < 0)
  1070.                 return ( i );
  1071.             if(c == '+')
  1072.                 num += i;
  1073.             else
  1074.                 num -= i;
  1075.         }
  1076.     }
  1077.     return ( num>LastLn ? ERR : num );
  1078. }  /* getone */
  1079.  
  1080.  
  1081. getlst()
  1082. {
  1083.     int    num;
  1084.  
  1085.     Line2 = 0;
  1086.     for(nlines = 0; (num = getone()) >= 0;)
  1087.     {
  1088.         Line1 = Line2;
  1089.         Line2 = num;
  1090.         nlines++;
  1091.         if(*inptr != ',' && *inptr != ';')
  1092.             break;
  1093.         if(*inptr == ';')
  1094.             CurLn = num;
  1095.         inptr++;
  1096.     }
  1097.     nlines = min(nlines, 2);
  1098.     if(nlines == 0)
  1099.         Line2 = CurLn;
  1100.     if(nlines <= 1)
  1101.         Line1 = Line2;
  1102.  
  1103.     return ( (num == ERR) ? num : nlines );
  1104. }  /* getlst */
  1105.  
  1106.  
  1107. /*    getptr.c    */
  1108.  
  1109. LINE *getptr(num)
  1110. int    num;
  1111. {
  1112.     LINE    *ptr;
  1113.     int    j;
  1114.  
  1115.     if (2*num>LastLn && num<=LastLn) {    /* high line numbers */
  1116.         ptr = Line0.l_prev;
  1117.         for (j = LastLn; j>num; j--)
  1118.             ptr = ptr->l_prev;
  1119.     } else {                /* low line numbers */
  1120.         ptr = &Line0;
  1121.         for(j = 0; j < num; j++)
  1122.             ptr = ptr->l_next;
  1123.     }
  1124.     return(ptr);
  1125. }
  1126.  
  1127.  
  1128. /*    getrhs.c    */
  1129.  
  1130. getrhs(sub)
  1131. char    *sub;
  1132. {
  1133.     if(inptr[0] == NL || inptr[1] == NL)    /* check for eol */
  1134.         return( ERR );
  1135.     if(maksub(sub, MAXPAT) == NULL)
  1136.         return( ERR );
  1137.  
  1138.     inptr++;        /* skip over delimter */
  1139.     Skip_White_Space;
  1140.     if(*inptr == 'g') {
  1141.         *inptr++;
  1142.         return( 1 );
  1143.     }
  1144.     return( 0 );
  1145. }
  1146.  
  1147.  
  1148. /*    gettxt.c    */
  1149. char *gettxt(num)
  1150. int    num;
  1151. {
  1152.     LINE    *lin;
  1153.     static char    txtbuf[MAXLINE];
  1154.  
  1155.     lin = getptr(num);
  1156.     strcpy(txtbuf,lin->l_buff);
  1157.     strcat(txtbuf,"\n");
  1158.     return(txtbuf);
  1159. }
  1160.  
  1161.  
  1162. /*    ins.c    */
  1163.  
  1164. ins(str)
  1165. char    *str;
  1166. {
  1167.     char    buf[MAXLINE], *cp;
  1168.     LINE    *new, *cur, *nxt;
  1169.  
  1170.     cp = buf;
  1171.     for (;;) {
  1172.         if((*cp = *str++) == NL)
  1173.             *cp = EOS;
  1174.         if(*cp) {
  1175.             cp++;
  1176.             continue;
  1177.         }
  1178.         if((new = (LINE *)malloc(sizeof(LINE)+strlen(buf))) == NULL)
  1179.             return( ERR );     /* no memory */
  1180.  
  1181.         new->l_stat=0;
  1182.         strcpy(new->l_buff,buf);    /* build new line */
  1183.         cur = getptr(CurLn);        /* get current line */
  1184.         nxt = getptr(nextln(CurLn));    /* get next line */
  1185.         relink(cur, new, new, nxt);    /* add to linked list */
  1186.         relink(new, nxt, cur, new);
  1187.         LastLn++;
  1188.         CurLn++;
  1189.  
  1190.         if(*str == EOS)        /* end of line ? */
  1191.             return( 1 );
  1192.  
  1193.         cp = buf;
  1194.     }
  1195. }
  1196.  
  1197.  
  1198. /*    join.c    */
  1199.  
  1200. int join(first, last)
  1201. int first, last;
  1202. {
  1203.     char buf[MAXLINE];
  1204.     char *cp=buf, *str;
  1205.     int num;
  1206.  
  1207.     if (first<=0 || first>last || last>LastLn)
  1208.         return(ERR);
  1209.     if (first==last) {
  1210.         CurLn=first;
  1211.         return 0;
  1212.     }
  1213.     for (num=first; num<=last; num++) {
  1214.         str=gettxt(num);
  1215.         while (*str!=NL && cp<buf+MAXLINE-1)
  1216.             *cp++ = *str++;
  1217.         if (cp==buf+MAXLINE-1) {
  1218.             puts("line too long");
  1219.             return(ERR);
  1220.         }
  1221.     }
  1222.     *cp++ = NL;
  1223.     *cp = EOS;
  1224.     del(first, last);
  1225.     CurLn=first-1;
  1226.     ins(buf);
  1227.     fchanged = TRUE;
  1228.     return 0;
  1229. }
  1230.  
  1231.  
  1232. /*    unmakepat.c
  1233.  * Free up the memory used for token string
  1234.  */
  1235. void unmakepat(head)
  1236. TOKEN    *head;
  1237. {
  1238.     register TOKEN    *old_head;
  1239.  
  1240.     while (head) {
  1241.         switch (head->tok) {
  1242.         case CCL:
  1243.         case NCCL:
  1244.             free(head->bitmap);
  1245.                 /* fall through to default */
  1246.         default:
  1247.             old_head = head;
  1248.             head = head->next;
  1249.             free (old_head);
  1250.             break;
  1251.         }
  1252.     }
  1253. }  /* unmakepat */
  1254.  
  1255.  
  1256. /*    makepat.c
  1257.  *
  1258.  * Make a pattern template from the strinng pointed to by arg.  Stop
  1259.  * when delim or '\000' or '\n' is found in arg.  Return a pointer to
  1260.  * the pattern template.
  1261.  *
  1262.  * The pattern template used here are somewhat different than those
  1263.  * used in the "Software Tools" book; each token is a structure of
  1264.  * the form TOKEN (see tools.h).  A token consists of an identifier,
  1265.  * a pointer to a string, a literal character and a pointer to another
  1266.  * token.  This last is 0 if there is no subsequent token.
  1267.  *
  1268.  * The one strangeness here is caused (again) by CLOSURE which has
  1269.  * to be put in front of the previous token.  To make this insertion a
  1270.  * little easier, the 'next' field of the last to point at the chain
  1271.  * (the one pointed to by 'tail) is made to point at the previous node.
  1272.  * When we are finished, tail->next is set to 0.
  1273.  */
  1274. TOKEN *makepat(arg, delim)
  1275. char    *arg;
  1276. int    delim;
  1277. {
  1278.      TOKEN    *head, *tail, *ntok;
  1279.      int    error;
  1280.  
  1281.     /*
  1282.      * Check for characters that aren't legal at the beginning of
  1283.      * a template.
  1284.      */
  1285.  
  1286.     if (*arg=='\0' || *arg==delim || *arg=='\n' || *arg==CLOSURE)
  1287.         return(0);
  1288.  
  1289.     error = 0;
  1290.     tail = head = NULL;
  1291.  
  1292.     while (*arg && *arg != delim && *arg != '\n' && !error) {
  1293.         ntok = (TOKEN *)malloc(TOKSIZE);
  1294.         ntok->lchar = '\000';
  1295.         ntok->next = 0;
  1296.  
  1297.         switch(*arg) {
  1298.         case ANY:
  1299.             ntok->tok = ANY;
  1300.             break;
  1301.  
  1302.         case BOL:
  1303.             if (head == 0)    /* then this is the first symbol */
  1304.                 ntok->tok = BOL;
  1305.             else {
  1306.                 ntok->tok = LITCHAR;
  1307.                 ntok->lchar = BOL;
  1308.             }
  1309.             break;
  1310.  
  1311.         case EOL:
  1312.             if (*(arg+1) == delim || *(arg+1) == '\000'
  1313.                 || *(arg+1) == '\n')
  1314.             {
  1315.                 ntok->tok = EOL;
  1316.             } else {
  1317.                 ntok->tok = LITCHAR;
  1318.                 ntok->lchar = EOL;
  1319.             }
  1320.             break;
  1321.  
  1322.         case CLOSURE:
  1323.             if (head != 0) {
  1324.                 switch (tail->tok) {
  1325.                 case BOL:
  1326.                 case EOL:
  1327.                 case CLOSURE:
  1328.                     return (0);
  1329.                 default:
  1330.                     ntok->tok = CLOSURE;
  1331.                 }
  1332.             }
  1333.             break;
  1334.  
  1335.         case CCL:
  1336.             if(*(arg + 1) == NEGATE) {
  1337.                 ntok->tok = NCCL;
  1338.                 arg += 2;
  1339.             } else {
  1340.                 ntok->tok = CCL;
  1341.                 arg++;
  1342.             }
  1343.  
  1344.             if( ntok->bitmap = makebitmap(CLS_SIZE) )
  1345.                 arg = dodash(CCLEND, arg, ntok->bitmap );
  1346.             else {
  1347.                 fprintf(stderr,"Not enough memory for pat\n");
  1348.                 error = 1;
  1349.             }
  1350.             break;
  1351.  
  1352.         default:
  1353.             if (*arg == ESCAPE && *(arg+1) == OPEN) {
  1354.                 ntok->tok = OPEN;
  1355.                 arg++;
  1356.             } else
  1357.             if (*arg == ESCAPE && *(arg+1) == CLOSE) {
  1358.                 ntok->tok = CLOSE;
  1359.                 arg++;
  1360.             } else {
  1361.                 ntok->tok = LITCHAR;
  1362.                 ntok->lchar = esc(&arg);
  1363.             }
  1364.         }
  1365.  
  1366.         if (error || ntok == 0) {
  1367.             unmakepat(head);
  1368.             return (0);
  1369.         } else
  1370.         if (head == 0) {    /* This is 1st node in the chain. */
  1371.             ntok->next = 0;
  1372.             head = tail = ntok;
  1373.         } else
  1374.         if (ntok->tok != CLOSURE) {
  1375.             /* Insert at end of list (after tail) */
  1376.             tail->next = ntok;
  1377.             ntok->next = tail;
  1378.             tail = ntok;
  1379.         } else
  1380.         if (head != tail) {
  1381.             /*
  1382.              * More than one node in the chain.  Insert the
  1383.              * CLOSURE node immediately in front of tail.
  1384.              */
  1385.             (tail->next)->next = ntok;
  1386.             ntok->next = tail;
  1387.         } else {
  1388.             /*
  1389.              * Only one node in the chain,  Insert the CLOSURE
  1390.              * node at the head of the linked list.
  1391.              */
  1392.             ntok->next = head;
  1393.             tail->next = ntok;
  1394.             head = ntok;
  1395.         }
  1396.         arg++;
  1397.     }
  1398.     tail->next = 0;
  1399.     return (head);
  1400. }
  1401.  
  1402.  
  1403. /*    maksub.c    */
  1404.  
  1405. char *maksub(char *sub, int subsz)
  1406. {
  1407.     int    size;
  1408.     char    delim, *cp;
  1409.  
  1410.     size = 0;
  1411.     cp = sub;
  1412.  
  1413.     delim = *inptr++;
  1414.     for(size = 0;
  1415.         *inptr != delim && *inptr != NL && size < subsz;
  1416.         size++)
  1417.     {
  1418.         if(*inptr == '&') {
  1419.             *cp++ = DITTO;
  1420.             inptr++;
  1421.         } else
  1422.         if((*cp++ = *inptr++) == ESCAPE) {
  1423.             if (size>=subsz)
  1424.                 return(NULL);
  1425.  
  1426.             switch(toupper(*inptr)) {
  1427.             case NL:
  1428.                 *cp++ == ESCAPE;
  1429.                 break;
  1430.             case 'S':
  1431.                 *cp++ = SP;
  1432.                 inptr++;
  1433.                 break;
  1434.             case 'N':
  1435.                 *cp++ = NL;
  1436.                 inptr++;
  1437.                 break;
  1438.             case 'T':
  1439.                 *cp++ = HT;
  1440.                 inptr++;
  1441.                 break;
  1442.             case 'B':
  1443.                 *cp++ = BS;
  1444.                 inptr++;
  1445.                 break;
  1446.             case 'R':
  1447.                 *cp++ = CR;
  1448.                 inptr++;
  1449.                 break;
  1450.             case '0': {
  1451.                 int i=3;
  1452.                 *cp = 0;
  1453.                 do {
  1454.                     if (*++inptr<'0' || *inptr >'7')
  1455.                         break;
  1456.                     *cp = (*cp<<3) | (*inptr-'0');
  1457.                 } while (--i!=0);
  1458.                 cp++;
  1459.                 } break;
  1460.             default:
  1461.                 *cp++ = *inptr++;
  1462.                 break;
  1463.             }
  1464.         }
  1465.     }
  1466.     if(size >= subsz)
  1467.         return( NULL );
  1468.  
  1469.     *cp = EOS;
  1470.     return( sub );
  1471. }
  1472.  
  1473.  
  1474. /*    matchs.c
  1475.  *
  1476.  * Compares line and pattern.  Line is a character string while pat
  1477.  * is a pattern template made by getpat().
  1478.  * Returns:
  1479.  *    1. A zero if no match was found.
  1480.  *
  1481.  *    2. A pointer to the last character satisfing the match
  1482.  *       if ret_endp is non-zero.
  1483.  *
  1484.  *    3. A pointer to the beginning of the matched string if
  1485.  *       ret_endp is zero.
  1486.  *
  1487.  * e.g.:
  1488.  *
  1489.  *    matchs ("1234567890", getpat("4[0-9]*7), 0);
  1490.  * will return a pointer to the '4', while:
  1491.  *
  1492.  *    matchs ("1234567890", getpat("4[0-9]*7), 1);
  1493.  * will return a pointer to the '7'.
  1494.  */
  1495. char *matchs(line, pat, ret_endp)
  1496. char    *line;
  1497. TOKEN    *pat;
  1498. int    ret_endp;
  1499. {
  1500.     char    *rval, *bptr;
  1501.  
  1502.     bptr = line;
  1503.  
  1504.     while(*line) {
  1505.         if ((rval = amatch(line, pat, bptr)) == 0)
  1506.             line++;
  1507.         else {
  1508.             if(rval > bptr && rval > line)
  1509.                 rval--;        /* point to last char matched */
  1510.             rval = ret_endp ? rval : line;
  1511.             break;
  1512.         }
  1513.     }
  1514.     return (rval);
  1515. }
  1516.  
  1517.  
  1518. /*  move.c
  1519.  *    Unlink the block of lines from Line1 to Line2, and relink them
  1520.  *    after line "num".
  1521.  */
  1522.  
  1523. int move(num)
  1524. int    num;
  1525. {
  1526.     int    range;
  1527.     LINE    *before, *first, *last, *after;
  1528.  
  1529.     if( Line1 <= num && num <= Line2 )
  1530.         return( ERR );
  1531.     range = Line2 - Line1 + 1;
  1532.     before = getptr(prevln(Line1));
  1533.     first = getptr(Line1);
  1534.     last = getptr(Line2);
  1535.     after = getptr(nextln(Line2));
  1536.  
  1537.     relink(before, after, before, after);
  1538.     LastLn -= range;    /* per AST's posted patch 2/2/88 */
  1539.     if (num > Line1)
  1540.         num -= range;
  1541.  
  1542.     before = getptr(num);
  1543.     after = getptr(nextln(num));
  1544.     relink(before, first, last, after);
  1545.     relink(last, after, before, first);
  1546.     LastLn += range;    /* per AST's posted patch 2/2/88 */
  1547.     CurLn = num + range;
  1548.     return( 1 );
  1549. }
  1550.  
  1551.  
  1552. int transfer(num)
  1553. int num;
  1554. {
  1555.     int mid, lin, ntrans;
  1556.  
  1557.     if (Line1<=0 || Line1>Line2)
  1558.         return(ERR);
  1559.  
  1560.     mid= num<Line2 ? num : Line2;
  1561.  
  1562.     CurLn=num;
  1563.     ntrans=0;
  1564.  
  1565.     for (lin=Line1; lin<=mid; lin++) {
  1566.         ins(gettxt(lin));
  1567.         ntrans++;
  1568.     }
  1569.     lin+=ntrans;
  1570.     Line2+=ntrans;
  1571.  
  1572.     for ( ; lin <= Line2; lin += 2 ) {
  1573.         ins(gettxt(lin));
  1574.         Line2++;
  1575.     }
  1576.     return(1);
  1577. }
  1578.  
  1579.  
  1580. /*    optpat.c    */
  1581.  
  1582. TOKEN *optpat(void)
  1583. {
  1584.     char    delim, str[MAXPAT], *cp;
  1585.  
  1586.     delim = *inptr++;
  1587.     cp = str;
  1588.     while(*inptr != delim && *inptr != NL) {
  1589.         if(*inptr == ESCAPE && inptr[1] != NL)
  1590.             *cp++ = *inptr++;
  1591.         *cp++ = *inptr++;
  1592.     }
  1593.  
  1594.     *cp = EOS;
  1595.     if(*str == EOS)
  1596.         return(oldpat);
  1597.     if(oldpat)
  1598.         unmakepat(oldpat);
  1599.     oldpat = getpat(str);
  1600.     return(oldpat);
  1601. }
  1602.  
  1603.  
  1604. set()
  1605. {
  1606.     char    word[16];
  1607.     int    i;
  1608.  
  1609.     if(*(++inptr) != 't') {
  1610.         if(*inptr != SP && *inptr != HT && *inptr != NL)
  1611.             return(ERR);
  1612.     } else
  1613.         inptr++;
  1614.  
  1615.     if ( (*inptr == NL)
  1616. #ifdef __TURBOC__
  1617.         || (*inptr == CR)
  1618. #endif
  1619.        )
  1620.     {
  1621.         printf("ed version %d.%d\n", version/100, version%100);
  1622.         printf(    "number %s, list %s\n",
  1623.             nflg?"ON":"OFF",
  1624.             lflg?"ON":"OFF");
  1625.         return(0);
  1626.     }
  1627.  
  1628.     Skip_White_Space;
  1629.     for(i = 0; *inptr != SP && *inptr != HT && *inptr != NL;)
  1630.         word[i++] = *inptr++;
  1631.     word[i] = EOS;
  1632.     for(t = tbl; t->t_str; t++) {
  1633.         if(strcmp(word,t->t_str) == 0) {
  1634.             *t->t_ptr = t->t_val;
  1635.             return(0);
  1636.         }
  1637.     }
  1638.     return SET_FAIL;
  1639. }
  1640.  
  1641.  
  1642. void relink(a, x, y, b)
  1643. LINE    *a, *x, *y, *b;
  1644. {
  1645.     x->l_prev = a;
  1646.     y->l_next = b;
  1647. }
  1648.  
  1649.  
  1650. void set_ed_buf(void)
  1651. {
  1652.     relink(&Line0, &Line0, &Line0, &Line0);
  1653.     CurLn = LastLn = 0;
  1654. }
  1655.  
  1656.  
  1657. /*    subst.c    */
  1658.  
  1659. subst(pat, sub, gflg, pflag)
  1660. TOKEN    *pat;
  1661. char    *sub;
  1662. int    gflg, pflag;
  1663. {
  1664.     int    lin, chngd, nchngd;
  1665.     char    *txtptr, *txt;
  1666.     char    *lastm, *m, *new, buf[MAXLINE];
  1667.  
  1668.     if(Line1 <= 0)
  1669.         return( SUB_FAIL );
  1670.     nchngd = 0;        /* reset count of lines changed */
  1671.     for(lin = Line1; lin <= Line2; lin++) {
  1672.         txt = txtptr = gettxt(lin);
  1673.         new = buf;
  1674.         chngd = 0;
  1675.         lastm = NULL;
  1676.         while(*txtptr) {
  1677.             if(gflg || !chngd)
  1678.                 m = amatch(txtptr, pat, txt);
  1679.             else
  1680.                 m = NULL;
  1681.             if(m != NULL && lastm != m) {
  1682.                 chngd++;
  1683.                 new = catsub(txtptr, m, sub, new, buf+MAXLINE);
  1684.                 lastm = m;
  1685.             }
  1686.             if(m == NULL || m == txtptr) {
  1687.                 *new++ = *txtptr++;
  1688.             } else {
  1689.                 txtptr = m;
  1690.             }
  1691.         }
  1692.         if(chngd) {
  1693.             if(new >= buf+MAXLINE)
  1694.                 return( SUB_FAIL );
  1695.             *new++ = EOS;
  1696.             del(lin,lin);
  1697.             ins(buf);
  1698.             nchngd++;
  1699.             if(pflag)
  1700.                 doprnt(CurLn, CurLn);
  1701.         }
  1702.     }
  1703.     return (( nchngd == 0 && !gflg ) ? SUB_FAIL : nchngd);
  1704. }
  1705.  
  1706.  
  1707. /*    system.c    */
  1708. #ifndef __TURBOC__
  1709.  
  1710. #define SHELL    "/bin/sh"
  1711.  
  1712. system(c)
  1713. char *c; {
  1714.     int pid, status;
  1715.  
  1716.     switch (pid = fork()) {
  1717.     case -1:
  1718.         return -1;
  1719.     case 0:
  1720.         execl(SHELL, "sh", "-c", c, (char *) 0);
  1721.         exit(-1);
  1722.     default:
  1723.         while (wait(&status) != pid)
  1724.             ;
  1725.     }
  1726.     return status;
  1727. }
  1728. #endif  /* ifndef __TURBOC__ */
  1729.  
  1730.  
  1731. /*  docmd.c
  1732.  *    Perform the command specified in the input buffer, as pointed to
  1733.  *    by inptr.  Actually, this finds the command letter first.
  1734.  */
  1735.  
  1736. int docmd(glob)
  1737. int    glob;
  1738. {
  1739.     static char    rhs[MAXPAT];
  1740.     TOKEN    *subpat;
  1741.     int    c, err, line3;
  1742.     int    apflg, pflag, gflag;
  1743.     int    nchng;
  1744.     char    *fptr;
  1745.  
  1746.     pflag = FALSE;
  1747.     Skip_White_Space;
  1748.  
  1749.     c = *inptr++;
  1750.     switch(c) {
  1751.     case NL:
  1752.         if( nlines == 0 && (Line2 = nextln(CurLn)) == 0 )
  1753.             return(ERR);
  1754.         CurLn = Line2;
  1755.         return (1);
  1756.         break;
  1757.  
  1758.     case '=':
  1759.         printf("%d\n",Line2);
  1760.         break;
  1761.  
  1762.     case 'a':
  1763.         if(*inptr != NL || nlines > 1)
  1764.             return(ERR);
  1765.  
  1766.         if(append(Line1, glob) < 0)
  1767.             return(ERR);
  1768.         fchanged = TRUE;
  1769.         break;
  1770.  
  1771.     case 'c':
  1772.         if(*inptr != NL)
  1773.             return(ERR);
  1774.  
  1775.         if(deflt(CurLn, CurLn) < 0)
  1776.             return(ERR);
  1777.  
  1778.         if(del(Line1, Line2) < 0)
  1779.             return(ERR);
  1780.         if(append(CurLn, glob) < 0)
  1781.             return(ERR);
  1782.         fchanged = TRUE;
  1783.         break;
  1784.  
  1785.     case 'd':
  1786.         if(*inptr != NL)
  1787.             return(ERR);
  1788.  
  1789.         if(deflt(CurLn, CurLn) < 0)
  1790.             return(ERR);
  1791.  
  1792.         if(del(Line1, Line2) < 0)
  1793.             return(ERR);
  1794.         if(nextln(CurLn) != 0)
  1795.             CurLn = nextln(CurLn);
  1796.         fchanged = TRUE;
  1797.         break;
  1798.  
  1799.     case 'e':
  1800.         if(nlines > 0)
  1801.             return(ERR);
  1802.         if(fchanged)
  1803.             return CHANGED;
  1804.         /*FALL THROUGH*/
  1805.     case 'E':
  1806.         if(nlines > 0)
  1807.             return(ERR);
  1808.  
  1809.         if(*inptr != ' ' && *inptr != HT && *inptr != NL)
  1810.             return(ERR);
  1811.  
  1812.         if((fptr = getfn()) == NULL)
  1813.             return(ERR);
  1814.  
  1815.         clrbuf();
  1816.         if((err = doread(0, fptr)) < 0)
  1817.             return(err);
  1818.  
  1819.         strcpy(fname, fptr);
  1820.         fchanged = FALSE;
  1821.         break;
  1822.  
  1823.     case 'f':
  1824.         if(nlines > 0)
  1825.             return(ERR);
  1826.  
  1827.         if(*inptr != ' ' && *inptr != HT && *inptr != NL)
  1828.             return(ERR);
  1829.  
  1830.         if((fptr = getfn()) == NULL)
  1831.             return(ERR);
  1832.  
  1833.         if (nofname)
  1834.             printf("%s\n", fname);
  1835.         else
  1836.             strcpy(fname, fptr);
  1837.         break;
  1838.  
  1839.     case 'i':
  1840.         if(*inptr != NL || nlines > 1)
  1841.             return(ERR);
  1842.  
  1843.         if(append(prevln(Line1), glob) < 0)
  1844.             return(ERR);
  1845.         fchanged = TRUE;
  1846.         break;
  1847.  
  1848.     case 'j':
  1849.         if (*inptr != NL || deflt(CurLn, CurLn+1)<0)
  1850.             return(ERR);
  1851.  
  1852.         if (join(Line1, Line2) < 0)
  1853.             return(ERR);
  1854.         break;
  1855.  
  1856.     case 'k':
  1857.         Skip_White_Space;
  1858.  
  1859.         if (*inptr < 'a' || *inptr > 'z')
  1860.             return ERR;
  1861.         c= *inptr++;
  1862.  
  1863.         if(*inptr != ' ' && *inptr != HT && *inptr != NL)
  1864.             return(ERR);
  1865.  
  1866.         mark[c-'a'] = Line1;
  1867.         break;
  1868.  
  1869.     case 'l':
  1870.         if(*inptr != NL)
  1871.             return(ERR);
  1872.         if(deflt(CurLn,CurLn) < 0)
  1873.             return(ERR);
  1874.         if (dolst(Line1,Line2) < 0)
  1875.             return(ERR);
  1876.         break;
  1877.  
  1878.     case 'm':
  1879.         if((line3 = getone()) < 0)
  1880.             return(ERR);
  1881.         if(deflt(CurLn,CurLn) < 0)
  1882.             return(ERR);
  1883.         if(move(line3) < 0)
  1884.             return(ERR);
  1885.         fchanged = TRUE;
  1886.         break;
  1887.  
  1888.     case 'P':
  1889.     case 'p':
  1890.         if(*inptr != NL)
  1891.             return(ERR);
  1892.         if(deflt(CurLn,CurLn) < 0)
  1893.             return(ERR);
  1894.         if(doprnt(Line1,Line2) < 0)
  1895.             return(ERR);
  1896.         break;
  1897.  
  1898.     case 'q':
  1899.         if(fchanged)
  1900.             return CHANGED;
  1901.         /*FALL THROUGH*/
  1902.     case 'Q':
  1903.         if(*inptr == NL && nlines == 0 && !glob)
  1904.             return(EOF);
  1905.         else
  1906.             return(ERR);
  1907.  
  1908.     case 'r':
  1909.         if(nlines > 1)
  1910.             return(ERR);
  1911.  
  1912.         if(nlines == 0)            /* The original code tested */
  1913.             Line2 = LastLn;        /*    if(nlines = 0)        */
  1914.                         /* which looks wrong.  RAM  */
  1915.  
  1916.         if(*inptr != ' ' && *inptr != HT && *inptr != NL)
  1917.             return(ERR);
  1918.  
  1919.         if((fptr = getfn()) == NULL)
  1920.             return(ERR);
  1921.  
  1922.         if((err = doread(Line2, fptr)) < 0)
  1923.             return(err);
  1924.         fchanged = TRUE;
  1925.         break;
  1926.  
  1927.     case 's':
  1928.         if(*inptr == 'e')
  1929.             return(set());
  1930.         Skip_White_Space;
  1931.         if((subpat = optpat()) == NULL)
  1932.             return(ERR);
  1933.         if((gflag = getrhs(rhs)) < 0)
  1934.             return(ERR);
  1935.         if(*inptr == 'p')
  1936.             pflag++;
  1937.         if(deflt(CurLn, CurLn) < 0)
  1938.             return(ERR);
  1939.         if((nchng = subst(subpat, rhs, gflag, pflag)) < 0)
  1940.             return(ERR);
  1941.         if(nchng)
  1942.             fchanged = TRUE;
  1943.         break;
  1944.  
  1945.     case 't':
  1946.         if((line3 = getone()) < 0)
  1947.             return(ERR);
  1948.         if(deflt(CurLn,CurLn) < 0)
  1949.             return(ERR);
  1950.         if(transfer(line3) < 0)
  1951.             return(ERR);
  1952.         fchanged = TRUE;
  1953.         break;
  1954.  
  1955.     case 'W':
  1956.     case 'w':
  1957.         apflg = (c=='W');
  1958.  
  1959.         if(*inptr != ' ' && *inptr != HT && *inptr != NL)
  1960.             return(ERR);
  1961.  
  1962.         if((fptr = getfn()) == NULL)
  1963.             return(ERR);
  1964.  
  1965.         if(deflt(1, LastLn) < 0)
  1966.             return(ERR);
  1967.         if(dowrite(Line1, Line2, fptr, apflg) < 0)
  1968.             return(ERR);
  1969.         fchanged = FALSE;
  1970.         break;
  1971.  
  1972.     case 'x':
  1973.         if(*inptr == NL && nlines == 0 && !glob) {
  1974.             if((fptr = getfn()) == NULL)
  1975.                 return(ERR);
  1976.             if(dowrite(1, LastLn, fptr, 0) >= 0)
  1977.                 return(EOF);
  1978.         }
  1979.         return(ERR);
  1980.  
  1981.     case 'z':
  1982.         if(deflt(CurLn,CurLn) < 0)
  1983.             return(ERR);
  1984.  
  1985.         switch(*inptr) {
  1986.         case '-':
  1987.             if(doprnt(Line1-21,Line1) < 0)
  1988.                 return(ERR);
  1989.             break;
  1990.  
  1991.         case '.':
  1992.             if(doprnt(Line1-11,Line1+10) < 0)
  1993.                 return(ERR);
  1994.             break;
  1995.  
  1996.         case '+':
  1997.         case '\n':
  1998.             if(doprnt(Line1,Line1+21) < 0)
  1999.                 return(ERR);
  2000.             break;
  2001.         }
  2002.         break;
  2003.  
  2004.     default:
  2005.         return(ERR);
  2006.     }
  2007.     return (0);
  2008. }  /* docmd */
  2009.  
  2010.  
  2011. /*    doglob.c    */
  2012. doglob()
  2013. {
  2014.     int    lin, stat;
  2015.     char    *cmd;
  2016.     LINE    *ptr;
  2017.  
  2018.     cmd = inptr;
  2019.  
  2020.     for (;;) {
  2021.         for (lin=1; lin<=LastLn; lin++) {
  2022.             ptr = getptr(lin);
  2023.             if (ptr->l_stat & LGLOB)
  2024.                 break;
  2025.         }
  2026.         if (lin > LastLn)
  2027.             break;
  2028.  
  2029.         ptr->l_stat &= ~LGLOB;
  2030.         CurLn = lin;
  2031.         inptr = cmd;
  2032.         if((stat = getlst()) < 0)
  2033.             return(stat);
  2034.         if((stat = docmd(1)) < 0)
  2035.             return(stat);
  2036.     }
  2037.     return(CurLn);
  2038. }  /* doglob */
  2039.  
  2040.  
  2041. #ifndef __TURBOC__
  2042. /*
  2043.  *  Software signal 2 is caught and the result is to resume the main loop
  2044.  *  at the point where a command is prompted for.  Nothing in this code
  2045.  *  generates the software signal, so for TurboC / MSDOS it all seems
  2046.  *  pretty pointless.
  2047.  */
  2048. #include <setjmp.h>
  2049. jmp_buf    env;
  2050.  
  2051. intr()
  2052. {
  2053.     puts("intr()?");
  2054.     longjmp(env, 1);
  2055. }
  2056. #endif    /* !__TURBOC__ */
  2057.  
  2058.  
  2059. /*--------  main  ---------------------------------------------------------*/
  2060.  
  2061. void cdecl main(argc,argv)
  2062. int    argc;
  2063. char    **argv;
  2064. {
  2065.     int    stat, i, doflush;
  2066.  
  2067.     set_ed_buf();
  2068.     doflush=isatty(1);
  2069.  
  2070.     if (argc>1 && argv[1][0]=='-' && argv[1][1]==0) {
  2071.         diag = 0;
  2072.         argc--;
  2073.         argv++;
  2074.     }
  2075.     if(argc > 1) {
  2076.         for(i = 1; i < argc; i++) {
  2077.             if(doread(0,argv[i])==0) {
  2078.                 CurLn = 1;
  2079.                 strcpy(fname, argv[i]);
  2080.                 break;
  2081.             }
  2082.         }
  2083.     }
  2084.  
  2085.     for (;;) {
  2086.  
  2087. #ifndef __TURBOC__
  2088.         setjmp(env);
  2089.         putchar(':');        /*  The command-line prompt  */
  2090.         signal(2, intr);
  2091. #else    /* __TURBOC__ */
  2092.         putchar(':');        /*  The command-line prompt  */
  2093. #endif    /* !__TURBOC__ */
  2094.  
  2095.         if (doflush)
  2096.             fflush(stdout);
  2097.         if (fgets(inlin, sizeof(inlin),stdin) == NULL) {
  2098.             puts("Null input.");
  2099.             break;
  2100.         }
  2101.         if(*inlin == '!') {
  2102.             for(inptr = inlin; *inptr != NL; inptr++)
  2103.                 ;
  2104.             *inptr = EOS;
  2105.             system(inlin+1);
  2106.             continue;
  2107.         }
  2108.         inptr = inlin;
  2109.         if(getlst() >= 0)
  2110.             if((stat = ckglob()) != 0) {
  2111.                 if(stat >= 0 && (stat = doglob()) >= 0) {
  2112.                     CurLn = stat;
  2113.                     continue;
  2114.                 }
  2115.             } else {
  2116.                 if((stat = docmd(0)) >= 0) {
  2117.                     if(stat == 1)
  2118.                         doprnt(CurLn, CurLn);
  2119.                     continue;
  2120.                 }
  2121.             }
  2122.         switch (stat) {
  2123.         case EOF:
  2124.             _cleanup(); exit(0);
  2125.         case FATAL:
  2126.             fputs("FATAL ERROR\n",stderr);
  2127.             _cleanup(); exit(1);
  2128.         case CHANGED:
  2129.             puts("File has been changed.");
  2130.             break;
  2131.         case SET_FAIL:
  2132.             puts("`set' command failed.");
  2133.             break;
  2134.         case SUB_FAIL:
  2135.             puts("string substitution failed.");
  2136.             break;
  2137.         default:
  2138.             puts("Oops?");
  2139.             /*  Unrecognized or failed command (this  */
  2140.             /*  is SOOOO much better than "?" :-)      */
  2141.         }
  2142.     }
  2143. }  /* main */
  2144. /*________  end of source code  ____________________________________________*/
  2145.  
  2146.  
  2147. /*
  2148.  * Article 1981 of comp.os.minix:
  2149.  * From: ast@cs.vu.nl (Andy Tanenbaum)
  2150.  * Subject: Debugged version of V7 ed (replaces old one)
  2151.  * Message-ID: <1840@botter.cs.vu.nl>
  2152.  * Date: 31 Jan 88 16:40:06 GMT
  2153.  * Organization: VU Informatica, Amsterdam
  2154.  * Lines: 2365
  2155.  *
  2156.  * * * * * * * * * * * *
  2157.  *
  2158.  * Article 2015 of comp.os.minix:
  2159.  * From: ast@cs.vu.nl (Andy Tanenbaum)
  2160.  * Subject: Fix to ed.c I posted recently
  2161.  * Message-ID: <1841@botter.cs.vu.nl>
  2162.  * Date: 2 Feb 88 20:51:36 GMT
  2163.  * Organization: VU Informatica, Amsterdam
  2164.  * Lines: 4
  2165.  *
  2166.  * 2035a2036
  2167.  * >     LastLn -= Line2-Line1+1;
  2168.  * 2046a2048
  2169.  * >     LastLn += Line2-Line1+1;
  2170.  *
  2171.  * * * * * * * * * * * *
  2172.  *
  2173.  * Article 2053 of comp.os.minix:
  2174.  * From: dean@ndmath.UUCP (Dean Alvis)
  2175.  * Subject: ed.c tuneup
  2176.  * Keywords: minor adjustments
  2177.  * Message-ID: <930@ndmath.UUCP>
  2178.  * Date: 17 Feb 88 17:22:54 GMT
  2179.  * Organization: Math. Dept., Univ. of Notre Dame
  2180.  *
  2181.  *     I've enjoyed using the recently posted "ed", both on a UNIX
  2182.  * system and at home under CP/M. One minor annoyance is the slowness
  2183.  * of the write command for large (>>1000 lines) files. One solution
  2184.  * is to replace the calls to gettxt() (which in turn call getptr())
  2185.  * in dowrite(). I've lost the original, so can't provide diffs (sorry),
  2186.  * but the idea is to just use a LINE * in the loop in dowrite(), as
  2187.  * follows:
  2188.  *
  2189.  *     LINE *lptr;
  2190.  *     ...
  2191.  *     lptr = getptr(from);
  2192.  *     for(lin=from;lin<=to;lin++) {
  2193.  *         str = lptr->l_buff;
  2194.  *         ++lines;
  2195.  *         bytes += strlen(str)+1;    /* str + '\n' */
  2196.  *         if(fputs(str,fp) == EOF) {
  2197.  *             ...
  2198.  *         }
  2199.  *         fputc('\n',fp);
  2200.  *         lptr = lptr->l_next;
  2201.  *     }
  2202.  *
  2203.  * I've tested this version, and haven't run into trouble yet.
  2204.  * Also, this method avoids the strcpy and strcat to the static buffer
  2205.  * in gettxt(), which seem unnecessary (someone correct me if i'm
  2206.  * missing something here).
  2207.  *
  2208.  *     Another minor annoyance is the state of the current line
  2209.  * number after global commands - my preference is for the last modified
  2210.  * line to be the new current line. Replacing the return(0) by
  2211.  * return(CurLn) at the end of doglob() will produce this behavior.
  2212.  *
  2213.  *     dean
  2214.  * --
  2215.  * dean@ndmath.UUCP
  2216.  * Dean Alvis, Math. Dept., Univ. of Notre Dame, Notre Dame IN, 46556
  2217.  *
  2218.  *
  2219.  */
  2220.