[net.sources] Documentation and source for TI-Forth screen editor

mj@myrias.UUCP (Michal Jaegermann) (11/13/85)

*** REPLACE THIS LINE WITH YOUR MESSAGE ***


     To LCT - the author of an original TI-Forth editor


     You will find here a new screen oriented editor for TI-Forth.
For people with other systems, TI-Forth is a fig-forth with some
computer specific extensions.  The goal was to write a small
editor with a lot of futures, like autorepeating keys, overtype
and insert, some limited form of cut-and-paste, single-stepping
through source, execution of Forth from editor. Results are
below. Compiled code adds below 2K to system stuff.
WARNING: this is a FORTH editor - meaning that it does not force
you to make a stupid thing, but will not protect you if you are
really insistent.

     Porting to other system
     -----------------------
     Should be really not so hard. The editor actually operates
on a virtual 1K buffer with addresses starting at 0. This is
mapped on an actual edit buffer which is displayed on your CRT.
All gory system details are fairly well insulated. As an
evidence - the same editor is displayed on two different ways in
TI enviroment. Using a windowed 40-columns wide text display,
and also is "drawn" in 64-column bit-map mode. Remember - I am
still using old TV for a "monitor" with TI99/4a. Details of 40
columns display are on screens 20 and 21. Same stuff for
64-columns on screens 22 and 23. Screen 24 is also midly system
dependent since it assumes in mapping words that you are editing
1K block organized in 16 lines, every one 64 characters long.
Change apprioprately if necessary. Also a word RKEY, which
implements auto-repeating key, goes to a hardware address to
check if a new key was pressed from the last scan. Implement
your own. A standard KEY will work, but will not autorepeat. All
other stuff should not create problems. Keyboard scan is table
driven, so change it to suit your keyboard, habits and
preferences. Table is called ACTION.
      
      Instalation in TI-Forth
      ------------------------
      (this section for TI-Forth owners only)
      I'm sorry. You need some extra words. Required is CMOVE>
- move up a memory contents.
It requires on stack a starting address,  a target  address 
and count in bytes.  It will not do anything
if a count is not a positive.  For speed  reasons  definition
is in code.
   HEX CODE CMOVE> C0B9 , C079 , C039 , A002 ,
                   A042 , 0600 , 0601 , 0602 ,
                   1102 , D450 , 10FA , 045F ,
     You  will  also need a .S for a stack display.  It loads
as a one of  -DUMP  words  but  you  may  extract  definition
somewhere  else  if  you wish.  Three other are "convenience"
words - if you do not like them - edit the source and  forget
about them.  They are:
: \ IN  C/L + C/L MINUS AND IN ! ; IMMEDIATE
 (for comments - nearly standard)
: 2DUP OVER OVER ;
 (quite obvious)
: AT GOTOXY ;
 (since I am alergic on GOTOXY)
     And  more  thing  about 64 column display.  Since I have
problems with an overscan I moved a 64 column  editor  screen
to the right.
     This  is  done  by modification of SMASH on screen 65 of
the system disk.  In this code you will find (once only!)  an
entry  2000 , .   Replace  it  with 2008 , .  This will cause
end-of-lines to disappear, but I think that this is a smaller
problem.   If  you  are  lucky enough not to have an overscan
problem then leave SMASH alone but remove 2+  from  64-column
.CUR.  By the way:
     CLIST  (  n  --  )  (list contents of a block n ) may be
defined as
     : CLIST (  n  --  )  BLOCK L/SCR 0
               DO I C/L * OVER + C/L I SMASH VMBW LOOP DROP ; 
and you do not really need CLINE and CLOOP.
     The editor will trap all non-printable  characters  with
and exception DEL ( hex 7F ).  If this is going to bother you
add in EDI loop, right after RKEY the following: ` DUP 7F < *
`.  This will remove a problem.
     If  you  will find that a sensitivity of a keyboard does
not suit your taste - play around with a delay loop in  BLINK
and  constants  imbedded  in  RKEY.   They  are  not  exactly
independent but try yourself.
     After you have done all of the above you may  load  your
new editor (you typed it in before - didn't you?) and try how
to use it.
     To make life easier - if you will get ten enclosed screens
into a standard dis/var 80 text file you may use the utility
below to install them on your Forth disk. I have to admit that
this works really well with two drive (RAM drive ok), but it
will work on one drive with files up to 5 screens worth, or
you may extend it adding appriopriate WAIT_AND_PROMPT stuff to
allow for disk swapping. When writing to disk it will not use
more screens then "cnt}, even if a file is bigger. It will ask
you for file name, and when writing, will append old file if you
will respond with <enter>. (Use GETFILE to set up file name
without any other operation).

SCR# 89
 
( SCREENS TO FILE AND BACK MJ 10Jun85 )  0 CLOAD RECORDS
BASE->R HEX  43 CLOAD ~EOF 0 VARIABLE BUF 4E ALLOT
PABS @ 2 + BUF 1400 FILE #CP   #CP
: GETFILE  CR ." Filename: " PAD 40 20 FILL \ <enter> for old nm
  PAD 1+ 30 OVER OVER  EXPECT  -TRAILING 2- -DUP
   IF #CP  SET-PAB  VRBL  50 REC-LEN DUP ROT 1- C!
             1+ PAD PAB@ 9 + ROT VMBW ELSE DROP APPND ENDIF ;
: SCNS>FILE ( scn# cnt -- )  GETFILE OPN OVER + SWAP DO I BLOCK
  400 OVER + SWAP DO I BUF 20 MOVE BUF 40 -TRAILING 1 MAX  WRT
      DROP  40 +LOOP  LOOP CLSE ; \ to append, <enter> for fname
: FILE>SCNS ( scn# cnt -- ) GETFILE OPN       OVER + SWAP
  DO ~EOF IF I BLOCK UPDATE 400 OVER OVER 20 FILL OVER + SWAP
    DO ~EOF IF RD BUF I ROT CMOVE ELSE LEAVE ENDIF 40 +LOOP
           ENDIF LOOP CLSE ;
: RECORDS #CP INPT OPN 0 DO ~EOF IF CR BUF RD TYPE PAUSE
    ELSE 1 ENDIF IF LEAVE ENDIF LOOP CLSE ;              R->BASE
 
 
     How to save youorself more typing
     ---------------------------------
     Send us your disk in  a  self-addressed  mailer  with  a
proper postage included (if not in CANADA you may buy in your
post office a proper amount of things called "Coupon  Reponse
International").   You  will  get  back  a  modified TI-Forth
system disk with this editor an many  other  handy  utilities
included.  It is really worth it.  Our address is
           EDMONTON 99'er COMPUTER USER'S SOCIETY
             P.O. BOX 11983, EDMONTON, ALBERTA
                       CANADA T5J 3L1
 
 ---------------------------------------------------------------------
	   once again a general stuff
 --------------------------------------------------------------------

     Starting and leaving editor
     ---------------------------
     As usual.  20 EDIT will bring on your screen a  contents
of  a  block  20 with an edit cursor in a home position.  ED@
will restart editor on last screen used with cursor at home
position. WHERE brings you to a location of a LOAD error.
     One  extra  -  ER  (EditResume) recals not only the last
screen but also the last cursor position.   So  you  will  be
back  where  you  left the editor the last time.  Once in the
editor ctrl-E will switch to  the  previous  screen  (a  home
positon), and ctrl-X to the next one.  Fctn-9 to get out.
 
     Entering text
     -------------
     Editor  will  come  up in an overtype mode.  So whatever
you are typing replaces a text under cursor.  Fctn-2  toggles
between  overtype and an insert modes.  While inserting a new
text pushes an old text to the right.   Whatever  will  spill
over the right margin is lost.
 
     Marking and unmarking text
     --------------------------
     Think  of  it  that  way.   You  have always exactly two
marks.  If they are invisible then they are  end  of  current
line  and  your  cursor position.  Ctrl-Z puts a visible mark
where your cursor is.  The first one will replace (as mark) a
cursor  position,  the second one - end of line.  If you will
try to put a third mark on a screen - the second one will  be
replaced with a new one.  Visible
marks  are  stored  on stack, so if you have to move the
first one, SWAP them (how to do it  -  later).   Ctrl-U  will
erase all visible marks from your screen.
 
     Deleting and inserting in one line
     ----------------------------------
Fctn-1   will  delete  one  character.   Remember  -  it
autorepeats.
Fctn-3 deletes the whole current line and all subsequent
text  moves  up.  Deleted line is stored in an delete buffer.
Ctrl-8 opens a blank line over the cursor.  Old last line  is
lost.  So everything like one should expext.
Fnct-7  removes  all  text  between  marks  (visible  or
invisible) and replaces it with blanks.  Up to 64  characters
of  removed  text are stored in a delete buffer.  If there is
more - they are lost.
     Action of fctn-8 depends on an editor mode.  In overtype
mode it acts as ctrl-8 but moving a text from a delete buffer
into an opened line.  While in isert mode - it inserts a text
from a delete buffer, WHITHOUT leading and trailing (but one)
blanks in line, on a cursor  position.   Old  text  moves  to
right.   A right margin spillover is lost.  Reread section on
marking and experiment until you will feel comfortable.
     Do not hold fnct-7 too long, since it will clobber  your
delete buffer with freshly created blanks.
     On  the top of it you may Yank text to the delete buffer
with ctrl-Y.  This will  put  away  text  between  marks  for
subsequent  fctn-8 inserting WITOUT removing an original from
a screen.  Same Same limitations as above will apply here.
 
     Moving around
     -------------
     Usual "arrow keys" will work - fnct-S, fctn-X, fctn-E,
fctn-D.
But also you have a "terminal style" controls, i.e.  ctrl-H
left, ctrl-J down, ctrl-K up and ctrl-L right.  They are handy
when singlestepping through a source.  Moreover ctrl-R will move
to the right in one word steps.  No key for a similar movement
backwards.
 
     Singlestep and executing Forth
     ------------------------------
     Ctrl-W  will  execute  (if  possible)  any  word on your
screen which is pointed  by  the  cursor.   The  cursor  will
advance  to the next word and below your edit screen you will
see a display of stack.
     Great for debugging.  Ctrl-Q will do the same  with  two
words  (try  0  CLOAD EDIT).  Do not try to execute compiling
words like DO of IF since you will  get  an  error.   No  big
deal,  ER  will put you where you just have been, but a stack
will be lost.
     You may also hit ctrl-.  to run an internal interpreter.
You  will  be put below an edit screen and you may type there
up to 80 characters of Forth to execute.  Upon enter you will
return  automatically  to the editor and a current stack will
be displayed below.  The editor part of a  screen  is  frozen
and  will  not  scroll  even if you will dump a whole memory.
This means that if you will make an error  then  to  unfreeze
the  screen,  you  have to return to editor (ER is ok) to get
out later with fctn-9.
     This is interpreter is even flexible enough to  start  a
compilation  (say  with  a  colon  definition),  to return to
editor,  to  do  some  editing  and  to  resume  a  suspended
compilation  later.  I am not advising you to use it normally
in that way, but this is a great way to see for yourself  how
a  compiler security is implemented and what DO is putting on
stack to tell LOOP where to branch.
     You will find out that  in  particular  you  may,  using
ctrl-.,  call editor itself - executing, for example, EDIT or
ER.  I would rather advise you not to  do  that.   Reason  is
that  you  are  stroring  on a return stack a return address.
So, once you would like to get out and hit  fctn-9  you  will
return...   back  to editor (previous instance).  If you will
do that many times getting back to FORTH may take a number of
fctn's-9's.  Ctrl-.  and QUIT will always save a day.
 
     How to move big blocks
     ----------------------
     The editor above of course can be extended and made more
powerful.  But a goal was to make it convenient, nice and not
too  big.   For  example,  one  may add big delete buffer and
rewrite deleting and inserting a little bit  to  get  a  full
"cut-and-paste".  But instead of doing this I am rather using
ctrl-.  feature on those unfrequent ocasions when I need more
extensive  capabilities.   For example - how to move block of
five lines from screen number 23 into some other location  on
screen 37.  Type 23 EDIT.  In the editor hit ctrl-.  and once
outside
     EDITOR *CUR.  A word *CUR from vocabulary EDITOR returns
an  address  in an edit buffer which corresponds to a current
cursor position.  You will see it on stack.  Now  ctrl-9  and
37  EDIT.   Once  back  in  the editor put your cursor on the
position when you would like  to  see  your  block  and  type
ctrl-.   *CUR  C/L 5 * CMOVE <enter>.  You will find yourself
back in the editor on  the  very  beginning  of  an  improted
block.   To  mark  the  block  as  an updated just retype one
character on screen.  FLUSH will save all  changes  to  disk.
Other   useful,   for   such  operations,  word  from  EDITOR
vocabulary is ROOM.  See source screens for details.

     To make life easier - here is
     A short refernce
     ----------------
 
fnct-1  delete character
fnct-2  toggle overtype/insert modes
fnct-3  delete line
fnct-5  swap windows in text mode / home in bit-map mode
fnct-6  move right
fnct-7  delete between marks ( one or both may be defaults )
fnct-8  insert text from PAD
        * in an ovetype mode inserts a new line moving other
        text down
        * in insert mode insert contents of PAD on a cursor
        position shifting text on the line to the right
fnct-9  leave editor
fnct-(S,X,E,D) move cursor to the (left, down, up, right)
 
ctrl-8  open blank line
ctrl-(E,X) get the (previous, next) screen
ctrl-W  execute one Word pointed by cursor  - display stack
ctrl-Q  execute two words pointed by cursor - display stack
ctrl-R  move Right one word
ctrl-Y  Yank - store text between marks (64 max) in edit buffer
ctrl-(H,J,K,L) move (left, down, up, right) - terminal style
ctrl-Z  mark cursor positon
ctrl-U  Unmark - replace marks by defaults (cursor, end-of-line)
ctrl-.  escape from editor to execute Forth. All Forth
        available. After <enter> or 80 characters typed returns
        aoutomatically to the editor with a display of a stack.
        If you will get an ERROR type ER to return back to
        the editor. Otherwise an edit screen will be frozen.
***
 
     Source screens
     --------------
     Referenced screen numbers are as on my disk.  Remeber to
change them in LOAD statements if you will put them  in  some
other location.
 
SCR# 20
 
( SCREEN EDITOR - 40 column display 20SEP85*Michal Jaegermann )
( 0 CLOAD EDIT ) BASE @ HEX    21 CLOAD  RANDOMIZE
VOCABULARY EDITOR IMMEDIATE EDITOR DEFINITIONS      3 WIDTH !
0 VARIABLE S_H           0 VARIABLE CLE          0 VARIABLE INS
: BLINK CURPOS @ DUP VSBR SWAP 1E OVER VSBW C0 0 DO LOOP VSBW ;
     18 LOAD   \ load cursor positions and auto-repeating key
: HLIST  0 0 AT SCR @ ."  SCR # " . CR CR CR
    L/SCR 0 DO I 3 .R CR LOOP ;
: LINE. DUP SCR @ (LINE) DROP S_H @ 1D * +
    SWAP 28 * 7C +  23 VMBW ;
: UP#  DUP 3 + SWAP DO I 0A .R LOOP ."  " 4 2 AT ;
: +.0  3 0 DO ." +....0...." LOOP ;
: CLIST L/SCR 0 DO I LINE. LOOP ;
: LLIST  4 1 AT       1 UP# ." ...."  +.0 ." +" CLIST ;
: RLIST  4 1 AT ." 3" 4 UP# ." 0...." +.0       CLIST ;
-->
 
SCR# 21
 
( SCREEN EDITOR - 40 column display 20SEP85*Michal Jaegermann )
: ELIST  0 SCRN_START ! BASE->R DECIMAL HLIST S_H @
           IF RLIST ELSE LLIST ENDIF    R->BASE ;
 
: .CUR    COL S_H @ 2DUP 6 * 22 - MINUS >
    IF 0= 19 ELSE -4 ENDIF SWAP
    IF 1 S_H @ - S_H ! ELIST ENDIF - CUR C/L / 3 + AT ;
: ED>   2F8 SCRN_START ! PAGE 0 IN ! ;
: >ED   0   SCRN_START !  ELIST .CUR ;
: /INS/ 8F1 6 INS @ 1 OVER - INS ! 9C * 30 + VFILL ;
: FLIP  S_H @ -3A * 1D + +CUR .CUR ;
: BCK   NOP 2F8 DUP CURPOS ! C8 20 VFILL 8F1 6 84 VFILL
            R> DROP R> DROP ;  \ NOP is forward reference holder
 
    19 LOAD     \ load a generic (TI-Forth) editor
BASE ! ;S
 
SCR# 22
 
( SCREEN EDITOR - 64 column support 20SEP85*Michal Jaegermann )
0  CLOAD EDIT    BASE @ HEX      39 CLOAD LINE   33 CLOAD TEXT
             36 CLOAD GRAPHICS2  37 CLOAD SPLIT  41 CLOAD CLIST
VOCABULARY EDITOR IMMEDIATE  EDITOR DEFINITIONS       3 WIDTH !
2 VARIABLE S_H              \ value for conditional compilation
: CINIT 3800 DUP ' SATR !  DUP ' SPDTAB ! 800 / 6 VWTR
  D000 SP@ SATR 2 VMBW DROP
  0000 0000 0000 0000 1 SPCHAR  0 1 F 5 0 SPRITE
  0000 0000 0000 00E0 2 SPCHAR
  E040 4040 4040 E000 3 SPCHAR
  0 1000 10 VFILL   0D 7 VWTR ; \ colors of fg (10) and bg (0D)
0 VARIABLE RATE      0 VARIABLE CLE           0 VARIABLE INS
: BLINK RATE @ DUP 1 RATE +!  4 = IF -4 RATE ! ENDIF
    0< IF 1 0 SPRPAT ELSE 2 INS @ + 0 SPRPAT ENDIF
                          180 0 DO LOOP ;
  18 LOAD  -->  \ load cursor positions and auto-repeating key
 
SCR# 23
 
( SCREEN EDITOR - 64 column support 20SEP85*Michal Jaegermann )
: LINE. DUP SCR @ (LINE) ROT SMASH VMBW ;                  HEX
: HLIST BASE->R DECIMAL 0 0 AT ."  SCR # " . CR R->BASE ;
: .CUR CUR C/L /MOD 3 SLA 1+ SWAP 2+ 2 SLA 8 MAX SWAP
     0 SPRPUT ;
 
: /INS/  1 INS @ - INS ! ;
: ELIST  SCR @ DUP HLIST CLIST 30F0 8 0 VFILL ;
: FLIP   0 !CUR .CUR ; \ this is HOME - name for compatibility
: EOUT   1 0 SPRPAT 30F0 8 ROT VFILL CLS SCR @ HLIST 0 IN ! ;
: ED>    66 EOUT ;
: >ED       .CUR ;
: BCK    NOP FF EOUT QUIT ;  \ NOP is a forward reference holder
 
   19 LOAD     \ load a generic (TI-Forth) editor
BASE !  ;S
 
SCR# 24
 
( SCREEN EDITOR - cursor & auto/rpt  6OCT85*Michal Jaegermann )
HEX     0 CONSTANT CUR
: MAP  SCR @ BLOCK + ;
: *CUR CUR MAP       ;
: !CUR 0 MAX B/BUF 1- MIN ' CUR ! ;
: +CUR CUR + !CUR ;
: &ROW  CUR C/L MINUS AND ;  : NXT   &ROW C/L + MAP ;
: COL  CUR C/L 1- AND ;
 
: RKEY  BLINK ?KEY -DUP  IF CLE @ 1 CLE +!  \ waits long enough?
   0< IF 837C C@                            \ new key pressed  ?
        IF -18 CLE ! ELSE DROP [ LATEST PFA ]  LITERAL >R ENDIF
      ELSE -1 CLE ! ENDIF                   \ time out - accept
  ELSE -18 CLE ! [ S_H @ IN +! (       \ conditional compilation
  LATEST PFA ]  LITERAL >R ENDIF ;     ;S
  ) ]   KEY ENDIF ;             \ wait here for some key pressed
 
SCR# 25
 
( SCREEN EDITOR - marking & deleting 9OCT85*Michal Jaegermann )
: REDRAW ELIST .CUR UPDATE ;                              HEX
: RELINE 0D EMIT  CUR C/L / LINE. UPDATE ;
    1 VARIABLE UNMARKED
: MARKOUT DUP C@ 7F AND SWAP C! ;
: MARK *CUR DUP DUP C@ 80 OR SWAP C! UNMARKED @
   IF NXT 1- 0 UNMARKED ! ELSE SWAP MARKOUT ENDIF ELIST .CUR ;
: ~MARK UNMARKED @ 0=
     IF 2 0 DO MARKOUT LOOP 1 UNMARKED ! ELIST .CUR ENDIF ;
: MYMARKS UNMARKED @ IF *CUR NXT ELSE 2DUP ~MARK
         2DUP > IF SWAP ENDIF 1+ ENDIF ;   \ unsigned comparison
: RIP PAD C/L BLANKS OVER - C/L MIN PAD SWAP CMOVE> ;
: YANK MYMARKS RIP ;
: ~TAIL  MYMARKS 2DUP RIP OVER - BLANKS REDRAW ;
: ~LINE  ~MARK &ROW !CUR MYMARKS 2DUP RIP SWAP OVER
    B/BUF MAP - MINUS CMOVE 3C0 MAP C/L BLANKS REDRAW ;     -->
 
SCR# 26
 
( SCREEN EDITOR - moving text  17SEP85*Michal Jaegermann ) HEX
: ROOM   >R OVER + R> OVER - CMOVE> ;     ( from cnt below -- )
: MDOWN   &ROW DUP !CUR MAP DUP C/L B/BUF MAP ROOM ;
: OLINE   MDOWN C/L BLANKS  REDRAW ;
: RWORD *CUR DUP BL ENCLOSE DROP SWAP DROP + BL ENCLOSE
   DROP DROP + - MINUS +CUR ; \ move cursor to the next word
: RMOVE RWORD .CUR ;
 
: ILINE  INS @
    IF PAD BL ENCLOSE DROP DROP C/L OVER - >R + R>
    -TRAILING 1+ *CUR SWAP 2DUP
       NXT DUP >R ROOM OVER R> - MINUS MIN CMOVE
    ELSE  MDOWN PAD SWAP C/L CMOVE  ENDIF         REDRAW ;
: DEL BL NXT DUP *CUR DUP 1+ DUP >R SWAP ROT R> - CMOVE
    1- C! RELINE .CUR ;
-->
 
SCR# 27
 
( SCREEN EDITOR - cursor control    17SEP85*Michal Jaegermann )
: +.CUR     +CUR .CUR ;
: NWL C/L COL - +.CUR ;
: LEFT       -1 +.CUR ;   : RIGHT       1 +.CUR ;
: UP C/L MINUS  +.CUR ;   : DOWN      C/L +.CUR ;
 
: PUTCHAR *CUR INS @ IF DUP 1 NXT ROOM ENDIF C!
                RELINE 1 +.CUR ;
 
: NEWSCR CLS COL 22 > S_H ! ELIST .CUR ;
: +SCR SCR @ 1+ DISK_HI @ < SCR +! 0 !CUR NEWSCR ;
: -SCR SCR @ 1- 0 MAX       SCR  ! 0 !CUR NEWSCR ;
 
: ED.XE            1 ED> R> DROP ; IMMEDIATE
: ONEDO *CUR       0 ED> R> DROP ;
: TWODO *CUR RWORD 0 ED> R> DROP ;                      -->
 
SCR# 28
 
( SCREEN EDITOR - execution table   30SEP85*Michal Jaegermann )
: DOIT  IF  QUERY ELSE ( adr -- ) RWORD *CUR OVER - 1-
         C/L MIN TIB @ 2DUP + 0 SWAP C! SWAP CMOVE> ENDIF
    INTERPRET .S >ED ; IMMEDIATE
 
: WAIL   7 EMIT ;
 
' WAIL  CFA  DUP VARIABLE ACTION             ' ~TAIL CFA , \ 01
        DUP ,  ' DEL   CFA ,  ' /INS/ CFA ,  ' -SCR  CFA , \ 05
' ILINE CFA ,  ' ~LINE CFA ,  ' LEFT  CFA ,  ' RIGHT CFA , \ 09
' DOWN  CFA ,  ' UP    CFA ,  ' RIGHT CFA ,  ' NWL   CFA , \ 0D
' FLIP  CFA ,  ' BCK   CFA ,          DUP ,  ' TWODO CFA , \ 11
' RMOVE CFA ,          DUP ,          DUP ,  ' ~MARK CFA , \ 15
        DUP ,  ' ONEDO CFA ,  ' +SCR  CFA ,  ' YANK  CFA , \ 19
' MARK  CFA ,  ' ED.XE CFA ,          DUP ,          DUP , \ 1D
' OLINE CFA ,              ,                 -->           \ 1F
 
SCR# 29
 
( SCREEN EDITOR - main loop & entry 30SEP85*Michal Jaegermann )
                                                          HEX
: EDI   BEGIN RKEY DUP BL <
   IF 1 SLA ACTION + @ EXECUTE ELSE PUTCHAR ENDIF AGAIN ;
 
' ~MARK CFA ' BCK !  1F WIDTH !  FORTH DEFINITIONS
 
: ER EDITOR      [ S_H @ IN +! ( ]     \ conditional compilation
    VDPMDE @ 5 = 0= IF SPLIT CINIT ENDIF          [ 2 IN +! ) ]
 1 INS ! /INS/ NEWSCR BEGIN EDI [COMPILE] DOIT AGAIN ;
 
: WHERE EDITOR SCR ! 2- !CUR ER ;
: ED@   EDITOR       0  !CUR ER ;
: EDIT         SCR !        ED@ ;
 
;S
 
 --------------------- that's all -----------------------------
 Michal Jaegermann
 ...ihnp4!alberta!myrias!mj