-- file TEdit.mesa
-- last modified by Satterthwaite,  9-Mar-82 14:22:58

DIRECTORY
  Ascii: TYPE USING [CR, SP, TAB],
  DCSFileTypes: TYPE USING [tLeaderPage],
  Directory: TYPE USING [CreateFile, Error, Lookup, UpdateDates, ignore],
  Exec: TYPE USING [AddCommand, commandLine, w],
  File: TYPE USING [Capability, Permissions, delete, grow, read, shrink, write],
  FileStream: TYPE USING [Create, EndOf],
  Stream: TYPE USING [Handle, Delete, GetChar, PutChar],
  TTY: TYPE USING [Handle, GetLine, LineOverflow, PutChar, Rubout];

TEdit: PROGRAM
    IMPORTS Directory, Exec, FileStream, Stream, TTY = {

 -- characters and strings
 
  MAXCHAR: NAT = LAST[CHARACTER] - 0c;
  MAXSTR: NAT = 100;
  
  character: TYPE = [-1..MAXCHAR];
  string: TYPE = PACKED ARRAY [1..MAXSTR] OF character;
  
  ENDFILE:   character = -1;
  ENDSTR:    character =  0;
  BACKSPACE: character =  9;
  TAB:       character =  9;
  NEWLINE:   character = 13;
  BLANK:     character = 32;
  ESCAPE:    character = ord['@];
  
 -- file descriptors and io-related stuff
 
  MAXOPEN: NAT = 10;
  
  filedesc: TYPE = [0..MAXOPEN];
  
  IOERROR: filedesc = 0;
  STDIN:   filedesc = 1;
  STDOUT:  filedesc = 2;
  STDERR:  filedesc = 3;
  
  IOREAD:  INTEGER = 1;
  IOWRITE: INTEGER = 2;
  IOBOTH:  INTEGER = 3;  
  

-- standard (Pascal) procedures
   
  ord: PROC [c: CHARACTER] RETURNS [character] = INLINE {RETURN [c - 0c]};
  chr: PROC [c: character] RETURNS [CHARACTER] = INLINE {RETURN [c + 0c]};
  
  
-- file primitives
   
  tty: TTY.Handle;
 
  kbdline: STRING _ [MAXSTR];
  kbdx: CARDINAL;
  kbdend: BOOLEAN;
  
  
  readkbd: PROC = {
    IF (kbdend) THEN
      kbdline.length _ 0
    ELSE {
      ENABLE {
	TTY.LineOverflow => {
	  putcf[NEWLINE, STDERR];
	  message["*** line too long"L];
	  putcf[NEWLINE, STDERR];
	  RETRY};
	TTY.Rubout => {
	  IF (kbdline.length) > 0 THEN
	    RESUME
	  ELSE {
	    kbdend _ TRUE;
	    CONTINUE}}};
      IF (kbdline.length > 0)
       AND (kbdline[kbdline.length-1] = Ascii.CR) THEN
        kbdline.length _ kbdline.length - 1;	-- for ESC
      tty.GetLine[kbdline];
      IF kbdline.length >= kbdline.maxlength THEN
        [] _ ERROR TTY.LineOverflow[kbdline];
      kbdline[kbdline.length] _ Ascii.CR;
      kbdline.length _ kbdline.length + 1};
    kbdx _ 0};
	   
    
    
  filerec: TYPE = RECORD [
    type: {none, stream, tty} _ none,
    handle: Stream.Handle _ NIL];
    
  filetab: ARRAY filedesc OF filerec;
  
  accessmap: PROC [mode: INTEGER] RETURNS [File.Permissions] = {
    RETURN [SELECT mode FROM
      IOREAD => File.read,
      IOWRITE => File.write + File.grow + File.shrink + File.delete,
      IOBOTH => File.read + File.write + File.grow + File.shrink + File.delete,
      ENDCASE => File.read]};
    
  fdalloc: PROC RETURNS [fd: filedesc] = {
    -- find a free slot in filetab
    FOR fd IN (STDERR .. MAXOPEN] DO
      IF (filetab[fd].type = none) THEN EXIT
      REPEAT
        FINISHED => fd _ IOERROR; 
      ENDLOOP;
    RETURN};
  
  fileerror: ERROR = CODE;
  
  findfile: PROC [name: STRING, access: File.Permissions]
      RETURNS [File.Capability] = {
    cap: File.Capability;
    old: BOOLEAN _ (access = File.read);
    IF ~old THEN { 
      cap _ Directory.CreateFile[name, DCSFileTypes.tLeaderPage, 0
	      ! Directory.Error => {
		 IF type = fileAlreadyExists THEN GOTO fileExists 
		 ELSE GO TO fileProblem}];
      EXITS
        fileExists => old _ TRUE};
    IF old THEN
       cap _ Directory.Lookup[fileName: name, permissions: Directory.ignore
	! Directory.Error => {GO TO fileProblem}];
    RETURN [Directory.UpdateDates[cap, access]]
    EXITS
      fileProblem => ERROR fileerror};
  
  makestream: PROC [name: POINTER TO string, mode: INTEGER, fd: filedesc] = {
    i: INTEGER _ 0;
    intname: STRING _ [MAXSTR];
    WHILE (name[i+1] # ENDSTR) DO
      intname[i] _ chr[name[i+1]];
      i _ i + 1;
      ENDLOOP;
    intname.length _ i;
    filetab[fd] _ [
	type: stream,
	handle: FileStream.Create[findfile[intname, accessmap[mode]]]]};
  

  open: PROC [name: POINTER TO string, mode: INTEGER] RETURNS [fd: filedesc] = {
    fd _ fdalloc[];
    IF fd # IOERROR THEN {
      makestream[name, mode, fd ! fileerror => {GOTO fail}];
      EXITS fail => {filetab[fd] _ [type: none]; fd _ IOERROR}};
    RETURN};

  create: PROC [name: POINTER TO string, mode: INTEGER] RETURNS [filedesc] = open;
    -- check positioning of files opened for output
    
  close: PROC [fd: filedesc] = {
    SELECT filetab[fd].type FROM
      stream => {
        h: Stream.Handle = filetab[fd].handle;
	Stream.Delete[h]};
      tty => NULL;
      ENDCASE => NULL;
    filetab[fd] _ [type: none]};

  remove: PROC [s: POINTER TO string] = {
    -- this version just prints a message
    message["If we had remove, we would be deleting "L];
    putcf[TAB, STDERR];
    putstr[s, STDERR];
    putcf[NEWLINE, STDERR]};

  getc: PROC [c: POINTER TO character] RETURNS [character] = INLINE {
    RETURN [getcf[c, STDIN]]};

  getcf: PROC [c: POINTER TO character, fd: filedesc] RETURNS [character] = {
    SELECT filetab[fd].type FROM
      stream => {
        h: Stream.Handle = filetab[fd].handle;
	c^ _ IF FileStream.EndOf[h] THEN ENDFILE ELSE ord[h.GetChar[]]};
      tty =>
        IF (kbdx < kbdline.length) THEN {
	  c^ _ ord[kbdline[kbdx]];
	  kbdx _ kbdx + 1}
	ELSE {
	  readkbd[];
	  IF (kbdline.length = 0) THEN	-- iff kbdend
	    c^ _ ENDFILE
	  ELSE {
	    c^ _ ord[kbdline[kbdx]];
	    kbdx _ kbdx + 1}};
      ENDCASE => error["bad file descriptor"L];
    RETURN [c^]};

  getline: PROC [s: POINTER TO string, fd: filedesc, maxsize: INTEGER _ MAXSTR]
      RETURNS [BOOLEAN] = {
    i: INTEGER _ 1;
    c: character;
    DO
      s[i] _ getcf[@c, fd];
      i _ i + 1;
      IF (c = ENDFILE) OR (c = NEWLINE) OR (i >= maxsize) THEN EXIT
      ENDLOOP;
    IF (c = ENDFILE) THEN	-- went one too far
      i _ i - 1;
    s[i] _ ENDSTR;
    RETURN [c # ENDFILE]};


  putc: PROC [c: character] = INLINE {putcf[c, STDOUT]};

  putcf: PROC [c: character, fd: filedesc] = {
    SELECT filetab[fd].type FROM
      stream => {
        h: Stream.Handle = filetab[fd].handle;
	h.PutChar[chr[c]]};
      tty => tty.PutChar[chr[c]];
      ENDCASE => error["bad file descriptor"L]};

  putstr: PROC [s: POINTER TO string, fd: filedesc] = {
    i: INTEGER _ 1;
    WHILE (s[i] # ENDSTR) DO
      putcf[s[i], fd];
      i _ i + 1
      ENDLOOP};
      

-- errors and messages

  message: PROC [msg: STRING] = {
    FOR i: CARDINAL IN [0 .. msg.length) DO
      putcf[ord[msg[i]], STDERR] ENDLOOP};

  exit: ERROR = CODE;
  
  error: PROC [msg: STRING] = {
    message[msg];  ERROR exit};
   

-- command arg primitives

  MAXCMD: NAT = 20;

  cmdargs: [0 .. MAXCMD];
  cmd: ARRAY [1 .. MAXCMD] OF RECORD [idx, len: CARDINAL];
  
  getarg: PROC [n: INTEGER, str: POINTER TO string, maxsize: INTEGER]
      RETURNS [BOOLEAN] = {
    b: BOOLEAN _ ((n > 0) AND (n <= cmdargs));
    IF (b) THEN
      commandstr[cmd[n].idx, cmd[n].len, str, 1, maxsize];
    RETURN [b]};

  nargs: PROC RETURNS [INTEGER] = {RETURN [cmdargs]};
  
  commandstr: PROC [i, n: INTEGER,
      dest: POINTER TO string, j: INTEGER, maxsize: INTEGER] = {
    WHILE (n > 0) AND (j < maxsize) DO
      dest[j] _ ord[Exec.commandLine.s[i]];
      i _ i + 1;
      j _ j + 1;
      n _ n - 1;
      ENDLOOP;
    dest[j] _ ENDSTR}; 
  

-- utilities

 -- addstr: put c in outset[j] if it fits, increment j
  addstr: PROC [c: character, outset: POINTER TO string,
      j: POINTER TO INTEGER, maxset: INTEGER] RETURNS [added: BOOLEAN] = {
    IF (j^ > maxset) THEN
      added _ FALSE
    ELSE {
      outset[j^] _ c;
      j^ _ j^ + 1;
      added _ TRUE};
    RETURN};
	
 -- esc: map s[i^] into escaped character, increment i^
  esc: PROC [s: POINTER TO string, i: POINTER TO INTEGER] RETURNS [c: character] = {
    IF (s[i^] # ESCAPE) THEN
      c _ s[i^]
    ELSE IF (s[i^+1] = ENDSTR) THEN	-- @ not special at end
      c _ ESCAPE
    ELSE {
      i^ _ i^ + 1;
      IF (s[i^] = ord['n]) THEN
        c _ NEWLINE
      ELSE IF (s[i^] = ord['t]) THEN
        c _ TAB
      ELSE
      	c _ s[i^]};
    RETURN};

 -- isalphanum: true if c is a letter or digit
  isalphanum: PROC [c: character] RETURNS [BOOLEAN] = {
    RETURN [
      (c IN [ord['a] .. ord['z]])
       OR (c IN [ord['A] .. ord['Z]])
       OR (c IN [ord['0] .. ord['9]])]};

 -- isdigit: true if c is a digit
  isdigit: PROC [c: character] RETURNS [BOOLEAN] = INLINE {
    RETURN [c IN [ord['0] .. ord['9]]]};

 -- itoc: convert integer n to char string in s[i] ...
  itoc: PROC [n: INTEGER, s: POINTER TO string, i: INTEGER] RETURNS [next: INTEGER] = {
    IF (n < 0) THEN {
      s[i] _ ord['-];
      next _ itoc[-n, s, i+1]}
    ELSE {
      IF (n >= 10) THEN
	i _ itoc[n/10, s, i];
      s[i] _ n MOD 10 + ord['0];
      s[i+1] _ ENDSTR;
      next _ i+1};
    RETURN};
   
 -- scopy: copy string ar st src[i] to dest[j]
   scopy: PROC [src: POINTER TO string, i: INTEGER, 
       dest: POINTER TO string, j: INTEGER] = {
     WHILE (src[i] # ENDSTR) DO
       dest[j] _ src[i];
       i _ i + 1;
       j _ j + 1;
       ENDLOOP;
     dest[j] _ ENDSTR};

 -- ctoi: convert string at s[i] to integer, increment i
  ctoi: PROC [s: POINTER TO string, i: POINTER TO INTEGER] RETURNS [INTEGER] = {
    n, sign: INTEGER;
    WHILE (s[i^] = BLANK) OR (s[i^] = TAB) DO
      i^ _ i^ + 1 ENDLOOP;
    sign _ IF s[i^] = ord['-] THEN -1 ELSE 1;
    IF (s[i^] = ord['+]) OR (s[i^] = ord['-]) THEN
      i^ _ i^ + 1;
    n _ 0;
    WHILE (isdigit[s[i^]]) DO
      n _ 10*n + (s[i^] - ord['0]);
      i^ _ i^ + 1;
      ENDLOOP;
    RETURN [sign * n]};
   
 -- putdec: put decimal integer n in field width >= w
  putdec: PROC [n, w: INTEGER] = {
    s: string; 
    nd: INTEGER = itoc[n, @s, 1];
    FOR i: INTEGER IN [nd .. w] DO
      putc[BLANK] ENDLOOP;
    FOR i: INTEGER IN [1 .. nd-1] DO
      putc[s[i]] ENDLOOP};
      

-- edittype: types for in-memory version of edit

  stcode: TYPE = {ENDDATA, ERR, OK};	-- status returns

-- editcons: const declarations for edit

  MAXLINES: NAT = 30;	-- set small for testing
  MAXPAT: NAT = MAXSTR;
  CLOSIZE: NAT = 1;	-- size of a closure entry
  DITTO: character = -1;
  CLOSURE: character = ord['*];
  BOL: character = ord['%];
  EOL: character = ord['$];
  ANYCHAR: character = ord['?];
  CCL: character = ord['[];
  CCLEND: character = ord[']];
  NEGATE: character = ord['^];
  NCCL: character = ord['!];	-- cannot be the same as NEGATE
  LITCHAR: character = ord['c];
  CURLINE: character = ord['.];
  LASTLINE: character = ord['$];
  SCAN: character = ord['/];
  BACKSCAN: character = ord['\\];

  SEMICOL: character = ord[';];
  COMMA: character = ord[',];
  PERIOD: character = ord['.];
    
  ACMD: character = ord['a];
  CCMD: character = ord['c];
  DCMD: character = ord['d];
  ECMD: character = ord['e];
  EQCMD: character = ord['=];
  FCMD: character = ord['f];
  GCMD: character = ord['g];
  ICMD: character = ord['i];
  MCMD: character = ord['m];
  PCMD: character = ord['p];
  QCMD: character = ord['q];
  RCMD: character = ord['r];
  SCMD: character = ord['s];
  WCMD: character = ord['w];
  XCMD: character = ord['x];
  
-- editvar: variables for edit

  line1: INTEGER;		-- first line number
  line2: INTEGER;		-- second line number
  nlines: INTEGER;		-- # of line numbers specified
  curln: INTEGER;		-- current line, value of dot
  lastln: INTEGER;		-- last line, value of $
  
  pat: string;			-- pattern
  lin: string;			-- input line
  savefile: string;		-- remembered file name
  
-- editprim: editor buffer primitives
 
  buftype: TYPE = RECORD [		-- in-memory edit buffer entry
    txt: string,	-- text of line
    mark: BOOLEAN];	-- mark for line
  buf: ARRAY [0..MAXLINES] OF buftype;

  clrbuf: PROC = {
    -- clrbuf (in memory): initialize for new file
    NULL};	-- nothing to do
    
  gettxt: PROC [n: INTEGER, s: POINTER TO string] = {
    -- gettext (in memory): get text from line n into s
    scopy[@buf[n].txt, 1, s, 1]};
  
  blkmove: PROC [n1, n2, n3: INTEGER] = {
    -- blkmove: move block of lines n1..n2 to follow n3
    IF (n3 < n1-1) THEN {
      reverse[n3+1, n1-1];
      reverse[n1, n2];
      reverse[n3+1, n2]}
    ELSE IF (n3 > n2) THEN {
      reverse[n1, n2];
      reverse[n2+1, n3];
      reverse[n1, n3]}};
      
  reverse: PROC [n1, n2: INTEGER] = {
    -- reverse: reverse buf[n1]...buf[n2]
    WHILE (n1 < n2) DO
      temp: buftype = buf[n1];
      buf[n1] _ buf[n2];
      buf[n2] _ temp;
      n1 _ n1 + 1;
      n2 _ n2 - 1
      ENDLOOP};
  
  setbuf: PROC = {
    -- setbuf (in memory): initialize line storage buffer
    null: string;	-- value is ''
    null[1] _ ENDSTR;
    scopy[@null, 1, @buf[0].txt, 1];
    curln _ 0;
    lastln _ 0};
  
  puttxt: PROC [lin: POINTER TO string] RETURNS [stat: stcode] = {
    -- puttxt (in memory): put text from lin after curln
    stat _ ERR;
    IF (lastln < MAXLINES) THEN {
      lastln _ lastln + 1;
      scopy[lin, 1, @buf[lastln].txt, 1];
      putmark[lastln, FALSE];
      blkmove[lastln, lastln, curln];
      curln _ curln + 1;
      stat _ OK};
    RETURN};
    
  getmark: PROC [n: INTEGER] RETURNS [BOOLEAN] = {
    -- getmark: get mark from nth line
    RETURN [buf[n].mark]};
    
  putmark: PROC [n: INTEGER, m: BOOLEAN] = {
    -- putmark: put mark m on nth line
    buf[n].mark _ m};
    
         
-- editproc: procedures for edit
 
  amatch: PROC [lin: POINTER TO string, offset: INTEGER,
      pat: POINTER TO string, j: INTEGER] RETURNS [INTEGER] = {
    -- amatch: look for match of pat[j] ... at lin[offset] ...

    omatch: PROC [lin: POINTER TO string, i: POINTER TO INTEGER,
	pat: POINTER TO string, j: INTEGER] RETURNS [matched: BOOLEAN] = {
      -- omatch: match one patern element at pat[j]

      locate: PROC [c: character, pat: POINTER TO string,
	  offset: INTEGER] RETURNS [found: BOOLEAN _ FALSE] = {
	-- locate: look for c in character class at pat[offset]
	-- size of class is at pat[offset], characters follow
	i: INTEGER _ offset + pat[offset];	-- last position
	WHILE (i > offset) DO
	  IF (c = pat[i]) THEN {
	    found _ TRUE;
	    i _ offset}	-- force loop termination
	  ELSE
	    i _ i - 1
	  ENDLOOP;
	RETURN};

      advance: [-1..1] _ -1;
      IF (lin[i^] # ENDSTR) THEN
	SELECT pat[j] FROM
	  LITCHAR =>
	    IF (lin[i^] = pat[j+1]) THEN
	      advance _ 1;
	  BOL =>
	    IF (i^ = 1) THEN
	      advance _ 0;
	  ANYCHAR =>
	    IF (lin[i^] # NEWLINE) THEN
	      advance _ 1;
	  EOL =>
	    IF (lin[i^] = NEWLINE) THEN
	      advance _ 0;
	  CCL =>
	    IF (locate[lin[i^], pat, j+1]) THEN
	      advance _ 1;
	  NCCL =>
	    IF (lin[i^] # NEWLINE)
	     AND (~locate[lin[i^], pat, j+1]) THEN
	      advance _ 1;
	  ENDCASE =>
	    error["in omatch: can't happen"L];
      IF (advance >= 0) THEN {
	i^ _ i^ + advance;
	matched _ TRUE}
      ELSE
	matched _ FALSE;
      RETURN};

    patsize: PROC [pat: POINTER TO string, n: INTEGER]
	RETURNS [size: INTEGER] = {
      -- patsize: returns size of pattern entry at pat[n]
      SELECT pat[n] FROM
	LITCHAR => 
	  size _ 2;
	BOL, EOL, ANYCHAR =>
	  size _ 1;
	CCL, NCCL =>
	  size _ pat[n+1] + 2;
	CLOSURE =>
	  size _ CLOSIZE;
	ENDCASE => 
	  error["in patsize: can't happen"L];
      RETURN [size]};
	  
    i, k: INTEGER;
    done: BOOLEAN _ FALSE;
    WHILE (~done) AND (pat[j] # ENDSTR) DO
      IF (pat[j] = CLOSURE) THEN {
	j _ j + patsize[pat, j];	-- step over CLOSURE
	i _ offset;
	-- match as many as possible
	WHILE (~done) AND (lin[i] # ENDSTR) DO
	  IF (~omatch[lin, @i, pat, j]) THEN
	    done _ TRUE
	  ENDLOOP;
	-- i points to input char that made us fail
	-- match rest of pattern against rest of input
	-- shrink closure by 1 after each failure
	done _ FALSE;
	WHILE (~done) AND (i >= offset) DO
	  k _ amatch[lin, i, pat, j+patsize[pat, j]];
	  IF (k > 0) THEN 	-- matched rest of pattern
	    done _ TRUE
	  ELSE
	    i _ i - 1
	  ENDLOOP;
	offset _ k;	-- if k = 0 THEN  failure else success
	done _ TRUE}
      ELSE IF (~omatch[lin, @offset, pat, j]) THEN {
	offset _ 0;	-- non-closure
	done _ TRUE}
      ELSE	-- omatch succeeded on this pattern element
	j _ j + patsize[pat, j]
      ENDLOOP;
    RETURN [offset]};
      
  match: PROC [lin, pat: POINTER TO string] RETURNS [BOOLEAN] = {
    -- match: find match anywhere on line
    i: INTEGER _ 1;
    pos: INTEGER _ 0;
    WHILE (lin[i] # ENDSTR) AND (pos = 0) DO
      pos _ amatch[lin, i, pat, 1];
      i _ i + 1
      ENDLOOP;
    RETURN [pos > 0]};

  skipbl: PROC [s: POINTER TO string, i: POINTER TO INTEGER] = {
    -- skipbl: skip blanks and tabs at s[i] ...
    WHILE (s[i^] = BLANK) OR (s[i^] = TAB) DO
      i^ _ i^ + 1 ENDLOOP};
      
  optpat: PROC [lin: POINTER TO string, i: POINTER TO INTEGER]
      RETURNS [stat: stcode] = {
    -- optpat: get optional pattern from lin[i], increment i
      
    makepat: PROC [arg: POINTER TO string, start: INTEGER,
        delim: character, pat: POINTER TO string] RETURNS [INTEGER] = {
      -- makepat: make pattern from arg[i], terminate at delim

      getccl: PROC [arg: POINTER TO string, i: POINTER TO INTEGER,
	  pat: POINTER TO string, j: POINTER TO INTEGER] RETURNS [BOOLEAN] = {
	-- getccl: expand char class at arg[i] into pat[j]
	jstart: INTEGER;
	
	dodash: PROC [delim: character, src: POINTER TO string,
	    i: POINTER TO INTEGER, dest: POINTER TO string,
	    j: POINTER TO INTEGER, maxset: INTEGER] = {
	  -- dodash: expand set at src[i^] into dest[j^], stop at delim
	  DASH: character = ord['-];
	  WHILE (src[i^] # delim) AND (src[i^] # ENDSTR) DO
	    IF (src[i^] = ESCAPE) THEN
	      [] _ addstr[esc[src, i], dest, j, maxset]
	    ELSE IF (src[i^] # DASH) THEN
	      [] _ addstr[src[i^], dest, j, maxset]
	    ELSE IF (j^ <= 1) OR (src[i^+1] = ENDSTR) THEN
	      [] _ addstr[DASH, dest, j, maxset]	-- literal -
	    ELSE IF (isalphanum[src[i^-1]])
	     AND (isalphanum[src[i^+1]])
	     AND (src[i^-1] <= src[i^+1]) THEN {
	      FOR k: character IN (src[i^-1] .. src[i^+1]] DO
		[] _ addstr[k, dest, j, maxset] ENDLOOP;
	      i^ _ i^ + 1}
	    ELSE
	      [] _ addstr[DASH, dest, j, maxset];
	    i^ _ i^ + 1
	    ENDLOOP};
	
	i^ _ i^ + 1;	-- skip over '[
	IF (arg[i^] = NEGATE) THEN {
	  [] _ addstr[NCCL, pat, j, MAXPAT];
	  i^ _ i^ + 1}
	ELSE
	  [] _ addstr[CCL, pat, j, MAXPAT];
	jstart _ j^;
	[] _ addstr[0, pat, j, MAXPAT];	-- room for count
	dodash[CCLEND, arg, i, pat, j, MAXPAT];
	pat[jstart] _ j^ - jstart - 1;
	RETURN [arg[i^] = CCLEND]};
	
      stclose: PROC [pat: POINTER TO string, j: POINTER TO INTEGER,
	  lastj: INTEGER] = {
	-- stclose: insert closure entry at pat[j]
	FOR jp: INTEGER DECREASING IN [lastj .. j^) DO
	  jt: INTEGER _ jp + CLOSIZE;
	  [] _ addstr[pat[jp], pat, @jt, MAXPAT]
	  ENDLOOP;
	j^ _ j^ + CLOSIZE;
	pat[lastj] _ CLOSURE};	-- where original pattern began
	
      i: INTEGER _ start;	-- arg index
      j: INTEGER _ 1;		-- pat index
      lastj: INTEGER _ 1;
      done: BOOLEAN _ FALSE;
      WHILE (~done) AND (arg[i] # delim) AND (arg[i] # ENDSTR) DO
	lj: INTEGER _ j;
        IF arg[i] = ANYCHAR THEN
	  [] _ addstr[ANYCHAR, pat, @j, MAXPAT]
	ELSE IF (arg[i] = BOL) AND (i = start) THEN
	  [] _ addstr[BOL, pat, @j, MAXPAT]
	ELSE IF (arg[i] = EOL) AND (arg[i+1] = delim) THEN
	  [] _ addstr[EOL, pat, @j, MAXPAT]
	ELSE IF (arg[i] = CCL) THEN
	  done _ (~getccl[arg, @i, pat, @j])
	ELSE IF (arg[i] = CLOSURE) AND (i > start) THEN {
	  lj _ lastj;
	  IF (pat[lj] = BOL) OR (pat[lj] = EOL) OR (pat[lj] = CLOSURE) THEN
	    done _ TRUE	-- force loop termination
	  ELSE
	    stclose[pat, @j, lastj]}
	ELSE {
	  [] _ addstr[LITCHAR, pat, @j, MAXPAT];
	  [] _ addstr[esc[arg, @i], pat, @j, MAXPAT]};
	lastj _ lj;
	IF (~done) THEN
	  i _ i + 1
	ENDLOOP;
      RETURN [
	IF (done) OR (arg[i] # delim) THEN 0	-- finished early
	ELSE IF (~addstr[ENDSTR, pat, @j, MAXPAT]) THEN 0	-- no room
	ELSE i]};	-- all is well;
      
    IF (lin[i^] = ENDSTR) THEN
      i^ _ 0
    ELSE IF (lin[i^+1] = ENDSTR) THEN
      i^ _ 0
    ELSE IF (lin[i^+1] = lin[i^]) THEN	-- repeated delimiter
      i^ _ i^ + 1	-- leave existing pattern alone
    ELSE
      i^ _ makepat[lin, i^+1, lin[i^], @pat];
    IF (pat[1] = ENDSTR) THEN
      i^ _ 0;
    IF (i^ = 0) THEN {
      pat[1] _ ENDSTR;
      stat _ ERR}
    ELSE stat _ OK;
    RETURN};
    
  nextln: PROC [n: INTEGER] RETURNS [INTEGER] = {
    -- nextln: get line after n
    RETURN [IF (n >= lastln) THEN 0 ELSE n + 1]};

  prevln: PROC [n: INTEGER] RETURNS [INTEGER] = {
    -- prevln: get line before n
    RETURN [IF (n <= 0) THEN lastln ELSE n - 1]};

  patscan: PROC [way: character, n: POINTER TO INTEGER] RETURNS [stat: stcode] = {
    -- patscan: find next occurrence of pattern after line n
    done: BOOLEAN _ FALSE;
    line: string;
    n^ _ curln;
    stat _ ERR;
    DO
      n^ _ IF (way = SCAN) THEN nextln[n^] ELSE prevln[n^];
      gettxt[n^, @line];
      IF (match[@line, @pat]) THEN {
        stat _ OK;
	done _ TRUE};
      IF (n^ = curln) OR (done) THEN EXIT
      ENDLOOP;
    RETURN};
    
  getnum: PROC [lin: POINTER TO string, i, num: POINTER TO INTEGER,
      status: POINTER TO stcode] RETURNS [stcode] = {
    -- getnum: get single line number component
    status^ _ OK;
    skipbl[lin, i];
    IF (isdigit[lin[i^]]) THEN {
      num^ _ ctoi[lin, i];
      i^ _ i^ - 1}	-- move back, to be advanced at end
    ELSE IF (lin[i^] = CURLINE) THEN
      num^ _ curln
    ELSE IF (lin[i^] = LASTLINE) THEN
      num^ _ lastln
    ELSE IF (lin[i^] = SCAN) OR (lin[i^] = BACKSCAN) THEN {
      IF (optpat[lin, i] = ERR) THEN	-- build pattern
        status^ _ ERR
      ELSE
        status^ _ patscan[lin[i^], num]}
    ELSE
      status^ _ ENDDATA;
    IF (status^ = OK) THEN
      i^ _ i^ + 1;	-- next character to be examined
    RETURN [status^]};
     
  getone: PROC [lin: POINTER TO string, i, num: POINTER TO INTEGER,
       status: POINTER TO stcode] RETURNS [stcode] = {
    -- getone: get one line number expression
    istart: INTEGER = i^;
    num^ _ 0;
    IF (getnum[lin, i, num, status] = OK) THEN	-- first term
      DO	-- + or - terms
        skipbl[lin, i];
	IF (lin[i^] # ord['+]) AND (lin[i^] # ord['-]) THEN
	  status^ _ ENDDATA
	ELSE {
	  pnum: INTEGER;
	  mul: INTEGER = IF (lin[i^] = ord['+]) THEN 1 ELSE -1;
	  i^ _ i^ + 1;
	  IF (getnum[lin, i, @pnum, status] = OK) THEN
	    num^ _ num^ + mul*pnum;
	  IF (status^ = ENDDATA) THEN
	    status^ _ ERR};
	IF (status^ # OK) THEN EXIT
	ENDLOOP;
    IF (num^ < 0) OR (num^ > lastln) THEN
       status^ _ ERR;
    IF (status^ # ERR) THEN
      status^ _ IF (i^ <= istart) THEN ENDDATA ELSE OK;
    RETURN [status^]};
      
  getlist: PROC [lin: POINTER TO string, i: POINTER TO INTEGER,
      status: POINTER TO stcode] RETURNS [stcode] = {
    -- getlist: get list of line nums at lin[i], increment i
    num: INTEGER;
    done: BOOLEAN;
    line2 _ 0;
    nlines _ 0;
    done _ (getone[lin, i, @num, status] # OK);
    WHILE (~done) DO
      line1 _ line2;
      line2 _ num;
      nlines _ nlines + 1;
      IF (lin[i^] = SEMICOL) THEN
        curln _ num;
      IF (lin[i^] = COMMA) OR (lin[i^] = SEMICOL) THEN {
        i^ _ i^ + 1;
	done _ (getone[lin, i, @num, status] # OK)}
      ELSE
        done _ TRUE
      ENDLOOP;
    nlines _ MIN[nlines, 2];
    IF (nlines = 0) THEN
      line2 _ curln;
    IF (nlines <= 1) THEN
      line1 _ line2;
    IF (status^ # ERR) THEN
      status^ _ OK;
    RETURN [status^]};

  append: PROC [line: INTEGER, glob: BOOLEAN] RETURNS [stat: stcode] = {
    -- append: append lines after "line"
    IF (glob) THEN
      stat _ ERR
    ELSE {
      inline: string;
      done: BOOLEAN _ FALSE;
      curln _ line;
      stat _ OK;
      WHILE (~done) AND (stat = OK) DO
        IF (~getline[@inline, STDIN, MAXSTR]) THEN
	  stat _ ENDDATA
	ELSE IF (inline[1] = PERIOD)
	 AND (inline[2] = NEWLINE) THEN
	  done _ TRUE
	ELSE IF (puttxt[@inline] = ERR) THEN
	  stat _ ERR
	ENDLOOP};
    RETURN};
    
  lndelete: PROC [n1, n2: INTEGER, status: POINTER TO stcode]
      RETURNS [stcode] = {
    -- lndelete: delete lines n1 through n2
    IF (n1 <= 0) THEN
      status^ _ ERR
    ELSE {
      blkmove[n1, n2, lastln];
      lastln _ lastln - (n1 - n1 + 1);
      curln _ prevln[n1];
      status^ _ OK};
    RETURN [status^]};
    
  doprint: PROC [n1, n2: INTEGER] RETURNS [stat: stcode] = {
    -- doprint: print lines n1 through n2
    line: string;
    IF (n1 <= 0) THEN
      stat _ ERR
    ELSE {
      FOR i: INTEGER IN [n1 .. n2] DO
        gettxt[i, @line];
	putstr[@line, STDOUT]
	ENDLOOP;
      curln _ n2;
      stat _ OK};
    RETURN};
    
  doread: PROC [n: INTEGER, fil: POINTER TO string] RETURNS [stat: stcode] = {
    -- doread: read "fil" after line n
    fd: filedesc = open[fil, IOREAD];
    IF (fd = IOERROR) THEN
      stat _ ERR
    ELSE {
      inline: string;
      count: INTEGER _ 0;
      curln _ n;
      stat _ OK;
      DO
        t: BOOLEAN = getline[@inline, fd, MAXSTR];
	IF (t) THEN {
	  stat _ puttxt[@inline];
	  IF (stat # ERR) THEN
	    count _ count + 1};
	IF (stat # OK) OR (~t) THEN EXIT
	ENDLOOP;
      close[fd];
      putdec[count, 1];
      putc[NEWLINE]};
    RETURN};
    
  dowrite: PROC [n1, n2: INTEGER, fil: POINTER TO string]
      RETURNS [stat: stcode] = {
    -- dowrite: write lines n1..n2 into file
    fd: filedesc = create[fil, IOWRITE];
    IF (fd = IOERROR) THEN
      stat _ ERR
    ELSE {
      line: string;
      FOR i: INTEGER IN [n1 .. n2] DO
        gettxt[i, @line];
	putstr[@line, fd]
	ENDLOOP;
      close[fd];
      putdec[n2-n1+1, 1];
      putc[NEWLINE];
      stat _ OK};
    RETURN};

  move: PROC [line3: INTEGER] RETURNS [stat: stcode] = {
    -- move: move line1 through line2 after line3
    IF (line1 <= 0) OR ((line3 >= line1) AND (line3 < line2)) THEN
      stat _ ERR
    ELSE {
      blkmove[line1, line2, line3];
      curln _ IF (line3 > line1)
        THEN line3
        ELSE line3 + (line2 - line1 + 1);
      stat _ OK};
    RETURN};
    
  makesub: PROC [arg: POINTER TO string, from: INTEGER,
      delim: character, sub: POINTER TO string] RETURNS [INTEGER] = {
    -- makesub: make substitution string from arg in sub
    i: INTEGER _ from;
    j: INTEGER _ 1;
    WHILE (arg[i] # delim) AND (arg[i] # ENDSTR) DO
      IF (arg[i] = ord['&]) THEN
	[] _ addstr[DITTO, sub, @j, MAXPAT]
      ELSE
	[] _ addstr[esc[arg, @i], sub, @j, MAXPAT];
      i _ i + 1
      ENDLOOP;
    RETURN [
      IF (arg[i] # delim) THEN 0	-- missing delimiter
      ELSE IF (~addstr[ENDSTR, sub, @j, MAXPAT]) THEN 0
      ELSE i]};
      

  getrhs: PROC [lin: POINTER TO string, i: POINTER TO INTEGER,
      sub: POINTER TO string, gflag: POINTER TO BOOLEAN] RETURNS [stat: stcode] = {
    -- getrhs: get right hand side of "s" command
    stat _ OK;
    IF (lin[i^] = ENDSTR) THEN
      stat _ ERR
    ELSE IF (lin[i^+1] = ENDSTR) THEN
      stat _ ERR
    ELSE {
      i^ _ makesub[lin, i^+1, lin[i^], sub];
      IF (i^ = 0) THEN
        stat _ ERR
      ELSE IF (lin[i^+1] = ord['g]) THEN {
        i^ _ i^ + 1;
	gflag^ _ TRUE}
      ELSE
        gflag^ _ FALSE};
    RETURN};
  
  catsub: PROC [lin: POINTER TO string, s1, s2: INTEGER,
      sub, new: POINTER TO string,
      k: POINTER TO INTEGER, maxnew: INTEGER] = {
    -- catsub: add replacement text to end of new
    i: INTEGER _ 1;
    WHILE (sub[i] # ENDSTR) DO
      IF (sub[i] = DITTO) THEN
        FOR j: INTEGER IN [s1 .. s2) DO
	  [] _ addstr[lin[j], new, k, maxnew] ENDLOOP
      ELSE
        [] _ addstr[sub[i], new, k, maxnew];
      i _ i + 1
      ENDLOOP};
      
  subst: PROC [sub: POINTER TO string, gflag, glob: BOOLEAN] RETURNS [stcode] = {
    -- subst: substitute "sub" for occurrences of pattern
    stat: stcode _ IF (glob) THEN OK ELSE ERR;
    done: BOOLEAN _ (line1 <= 0);
    line: INTEGER _ line1;
    new, old: string;
    WHILE (~done) AND (line <= line2) DO
      j, k: INTEGER _ 1;
      subbed: BOOLEAN _ FALSE;
      lastm: INTEGER _ 0;
      gettxt[line, @old];
      WHILE (old[k] # ENDSTR) DO
        m: INTEGER = IF (gflag) OR (~subbed)
	  THEN amatch[@old, k, @pat, 1]
	  ELSE 0;
	IF (m > 0) AND (lastm # m) THEN {
	  -- replace matched text
	  subbed _ TRUE;
	  catsub[@old, k, m, sub, @new, @j, MAXSTR];
	  lastm _ m};
	IF (m = 0) OR (m = k) THEN {
	  -- no match or null match
	  [] _ addstr[old[k], @new, @j, MAXSTR];
	  k _ k + 1}
	ELSE	-- skip matched text
	  k _ m
	ENDLOOP;
      IF (subbed) THEN {
        IF (~addstr[ENDSTR, @new, @j, MAXSTR]) THEN {
	  stat _ ERR;
	  done _ TRUE}
	ELSE {
	  stat _ lndelete[line, line, @stat];
	  stat _ puttxt[@new];
	  line2 _ line2 + curln - line;
	  line _ curln;
	  IF (stat = ERR) THEN
	    done _ TRUE
	  ELSE
	    stat _ OK}};
      line _ line + 1
      ENDLOOP;
    RETURN [stat]};
    
  ckp: PROC [lin: POINTER TO string, i: INTEGER,
      pflag: POINTER TO BOOLEAN, status: POINTER TO stcode] RETURNS [stcode] = {
    -- ckp: check for "p" after command
    skipbl[lin, @i];
    IF (lin[i] = PCMD) THEN {
      i _ i + 1;
      pflag^ _ TRUE}
    ELSE
      pflag^ _ FALSE;
    status^ _ IF (lin[i] = NEWLINE) THEN OK ELSE ERR;
    RETURN [status^]};
    
  default: PROC [def1, def2: INTEGER,
      status: POINTER TO stcode] RETURNS [stcode] = {
    -- default: set defaulted line numbers
    IF (nlines = 0) THEN {
      line1 _ def1;
      line2 _ def2};
    status^ _ IF (line1 > line2) OR (line1 <= 0) THEN ERR ELSE OK;
    RETURN [status^]};
    
  getfn: PROC [lin: POINTER TO string, i: POINTER TO INTEGER,
      fil: POINTER TO string] RETURNS [stat: stcode] = {
    -- getfn: get file name from lin[i] ...
      
    getword: PROC [s: POINTER TO string, i: INTEGER,
        out: POINTER TO string] RETURNS [INTEGER] = {
      j: INTEGER _ 1;
      WHILE (s[i] = BLANK) OR (s[i] = TAB) OR (s[i] = NEWLINE) DO
	i _ i + 1 ENDLOOP;
      WHILE (~((s[i] = ENDSTR)
       OR (s[i] = BLANK) OR (s[i] = TAB) OR (s[i] = NEWLINE))) DO
	out[j] _ s[i];
	i _ i + 1;
	j _ j + 1
	ENDLOOP;
      out[j] _ ENDSTR;
      RETURN [IF (s[i] = ENDSTR) THEN 0 ELSE i]};
	
    stat _ ERR;
    IF (lin[i^+1] = BLANK) THEN {
      k: INTEGER = getword[lin, i^+2, fil];	-- get new filename
      IF (k > 0) THEN
        IF (lin[k] = NEWLINE) THEN
	  stat _ OK}
    ELSE IF (lin[i^+1] = NEWLINE)
     AND (savefile[1] # ENDSTR) THEN {
      scopy[@savefile, 1, fil, 1];
      stat _ OK};
    IF (stat = OK) AND (savefile[1] = ENDSTR) THEN
      scopy[fil, 1, @savefile, 1];	-- save if no old one
    RETURN};
    
  docmd: PROC [lin: POINTER TO string, i: POINTER TO INTEGER,
      glob: BOOLEAN, status: POINTER TO stcode] RETURNS [stcode] = {
    -- docmd: handle all commands except globals
    pflag: BOOLEAN _ FALSE;	-- may be set by d, m, s
    status^ _ ERR;
    IF (lin[i^] = PCMD) THEN {
      IF (lin[i^+1] = NEWLINE) THEN
        IF (default[curln, curln, status] = OK) THEN
	  status^ _ doprint[line1, line2]}
    ELSE IF (lin[i^] = NEWLINE) THEN {
      IF (nlines = 0) THEN
        line2 _ nextln[curln];
      status^ _ doprint[line2, line2]}
    ELSE IF (lin[i^] = QCMD) THEN {
      IF (lin[i^+1]=NEWLINE) AND (nlines=0) AND (~glob) THEN
        status^ _ ENDDATA}
    ELSE IF (lin[i^] = ACMD) THEN {
      IF (lin[i^+1] = NEWLINE) THEN
        status^ _ append[line2, glob]}
    ELSE IF (lin[i^] = CCMD) THEN {
      IF (lin[i^+1] = NEWLINE) THEN
        IF (default[curln, curln, status] = OK) THEN
        IF (lndelete[line1, line2, status] = OK) THEN
	  status^ _ append[prevln[line1], glob]}
    ELSE IF (lin[i^] = DCMD) THEN {
      IF (ckp[lin, i^+1, @pflag, status] = OK) THEN
        IF (default[curln, curln, status] = OK) THEN
        IF (lndelete[line1, line2, status] = OK) THEN
        IF (nextln[curln] # 0) THEN
	  curln _ nextln[curln]}
    ELSE IF (lin[i^] = ICMD) THEN {
      IF (lin[i^+1] = NEWLINE) THEN
        IF (line2 = 0) THEN
	  status^ _ append[0, glob]
	ELSE
	  status^ _ append[prevln[line2], glob]}
    ELSE IF (lin[i^] = EQCMD) THEN {
      IF (ckp[lin, i^+1, @pflag, status] = OK) THEN {
	putdec[line2, 1];
	putc[NEWLINE]}}
    ELSE IF (lin[i^] = MCMD) THEN {
      line3: INTEGER;
      i^ _ i^ + 1;
      IF (getone[lin, i, @line3, status] = ENDDATA) THEN
        status^ _ ERR;
      IF (status^ = OK) THEN
        IF (ckp[lin, i^, @pflag, status] = OK) THEN
	IF (default[curln, curln, status] = OK) THEN
	  status^ _ move[line3]}
    ELSE IF (lin[i^] = SCMD) THEN {
      sub: string;
      gflag: BOOLEAN;
      i^ _ i^ + 1;
      IF (optpat[lin, i] = OK) THEN
        IF (getrhs[lin, i, @sub, @gflag] = OK) THEN
	IF (ckp[lin, i^+1, @pflag, status] = OK) THEN
	IF (default[curln, curln, status] = OK) THEN
	  status^ _ subst[@sub, gflag, glob]}
    ELSE IF (lin[i^] = ECMD) THEN {
      fil: string;
      IF (nlines = 0) THEN
        IF (getfn[lin, i, @fil] = OK) THEN {
	  scopy[@fil, 1, @savefile, 1];
	  clrbuf[];
	  setbuf[];
	  status^ _ doread[0, @fil]}}
    ELSE IF (lin[i^] = FCMD) THEN {
      fil: string;
      IF (nlines = 0) THEN
        IF (getfn[lin, i, @fil] = OK) THEN {
	  scopy[@fil, 1, @savefile, 1];
	  putstr[@savefile, STDOUT];
	  putc[NEWLINE];
	  status^ _ OK}}
    ELSE IF (lin[i^] = RCMD) THEN {
      fil: string;
      IF (getfn[lin, i, @fil] = OK) THEN
	status^ _ doread[line2, @fil]}
    ELSE IF (lin[i^] = WCMD) THEN {
      fil: string;
      IF (getfn[lin, i, @fil] = OK) THEN
        IF (default[1, lastln, status] = OK) THEN
	  status^ _ dowrite[line1, line2, @fil]}
    -- else status is ERR --;
    IF (status^ = OK) AND (pflag) THEN
      status^ _ doprint[curln, curln];
    RETURN [status^]};
    
  ckglob: PROC [lin: POINTER TO string, i: POINTER TO INTEGER,
      status: POINTER TO stcode] RETURNS [stcode] = {
    -- ckglob: if global prefix, mark lines to be affected
    IF (lin[i^] # GCMD) AND (lin[i^] # XCMD) THEN
      status^ _ ENDDATA
    ELSE {
      gflag: BOOLEAN = (lin[i^] = GCMD);
      i^ _ i^ + 1;
      IF (optpat[lin, i] = ERR) THEN
        status^ _ ERR
      ELSE IF (default[1, lastln, status] # ERR) THEN {
        temp: string;
	i^ _ i^ + 1;	-- mark affected lines
	FOR n: INTEGER IN [line1 .. line2] DO
	  gettxt[n, @temp];
	  putmark[n, (match[@temp, @pat] = gflag)]
	  ENDLOOP;
	FOR n: INTEGER IN [1 .. line1) DO	-- erase other marks
	  putmark[n, FALSE] ENDLOOP;
	FOR n: INTEGER IN (line2 .. lastln] DO
	  putmark[n, FALSE] ENDLOOP;
	status^ _ OK}};
    RETURN [status^]};
    
  doglob: PROC [lin: POINTER TO string, i, cursave: POINTER TO INTEGER,
      status: POINTER TO stcode] RETURNS [stcode] = {
    -- doglob: do command at lin[i] on all marked lines
    count: INTEGER _ 0;
    istart: INTEGER = i^;
    n: INTEGER _ line1;
    status^ _ OK;
    DO
      IF (getmark[n]) THEN {
        putmark[n, FALSE];
	curln _ n;
	cursave^ _ curln;
	i^ _ istart;
	IF (getlist[lin, i, status] = OK) THEN
	  IF (docmd[lin, i, TRUE, status] = OK) THEN
	    count _ 0}
      ELSE {
        n _ nextln[n];
	count _ count + 1};
      IF (count > lastln) OR (status^ # OK) THEN EXIT
      ENDLOOP;
    RETURN [status^]};
   
 -- edit: main routine for text editor
  edit: PROC = {
    more: BOOLEAN;
    setbuf[];
    pat[1] _ ENDSTR;
    savefile[1] _ ENDSTR;
    IF (getarg[1, @savefile, MAXSTR]) THEN
      IF (doread[0, @savefile] = ERR) THEN
        message["?"L];
    more _ getline[@lin, STDIN, MAXSTR];
    WHILE (more) DO
      cursave: INTEGER _ curln;
      i: INTEGER _ 1;
      status: stcode;
      IF (getlist[@lin, @i, @status] = OK) THEN {
        IF (ckglob[@lin, @i, @status] = OK) THEN
	  status _ doglob[@lin, @i, @cursave, @status]
	ELSE IF (status # ERR) THEN
	  status _ docmd[@lin, @i, FALSE, @status]
	-- ELSE ERR, do nothing--};
      IF (status = ERR) THEN {
        message["?"L];
	curln _ MIN[cursave, lastln]}
      ELSE IF (status = ENDDATA) THEN
        more _ FALSE;
      -- ELSE OK
      IF (more) THEN
        more _ getline[@lin, STDIN, MAXSTR]
      ENDLOOP;
    clrbuf[]};
      
  
 -- here begins the shell
 
  initcmd: PROC = {
    idx: CARDINAL _ Exec.commandLine.i;
    limx: CARDINAL =
      IF Exec.commandLine.s = NIL THEN 0 ELSE Exec.commandLine.s.length-1;
    tty _ Exec.w;
    kbdx _ kbdline.length _ 0;
    kbdend _ FALSE;
    filetab[STDIN].type _ filetab[STDOUT].type _ filetab[STDERR].type _ tty;
    cmdargs _ 0;
    WHILE (idx < limx) DO
      WHILE (Exec.commandLine.s[idx] = Ascii.SP) AND (idx < limx) DO
        idx _ idx + 1 ENDLOOP;
      IF (idx < limx) THEN {
        startidx: CARDINAL = idx;
	WHILE (idx < limx)
	 AND (Exec.commandLine.s[idx] # Ascii.SP)
	 AND (Exec.commandLine.s[idx] # Ascii.TAB) DO
	  idx _ idx + 1 ENDLOOP;
	SELECT Exec.commandLine.s[startidx] FROM
	  '< => {
	    name: string;
	    commandstr[startidx+1, idx - (startidx+1), @name, 1, MAXSTR];
	    close[STDIN];
	    makestream[@name, IOREAD, STDIN]};
	  '> => {
	    name: string;
	    commandstr[startidx+1, idx - (startidx+1), @name, 1, MAXSTR];
	    close[STDOUT];
	    makestream[@name, IOWRITE, STDOUT]};
	  ENDCASE => {
	    cmdargs _ cmdargs + 1;
	    IF cmdargs > MAXCMD THEN {
	      putcf[NEWLINE, STDERR];
	      message["*** too many arguments"L];
	      putcf[NEWLINE, STDERR]}
	    ELSE
	      cmd[cmdargs] _ [idx: startidx, len: idx - startidx]}};
      ENDLOOP;
    putcf[NEWLINE, STDERR]};
      
   endcmd: PROC = {
     FOR fd: filedesc IN (IOERROR .. MAXOPEN] DO
       close[fd] ENDLOOP;
     IF Exec.commandLine.s # NIL THEN
       Exec.commandLine.i _ Exec.commandLine.s.length};
   

  main: PROC = {
    initcmd[];
    edit[ ! exit => {CONTINUE}];
    endcmd[]};
  
  Exec.AddCommand["tedit.~"L, main];
  
  }.