;************************************************************************
;*                                                                      *
;*                      LINE EDIT ROUTINE                               *
;*                                                                      *
;************************************************************************
;(C) Copyright 1984 John Waycott - All Rights Reserved
;
;Permission is granted to freely copy this program provided that:
;
;       1. The copyright notices in this program must remain intact.
;       2. The program or modifications thereof are not sold for profit.
;
;If you have modifications, bug reports or enhancements please let me know.
;My address is:
;
;       John Waycott
;       6327 W Laredo St
;       Chandler, Az 85224
;       (702) 961-0193
;
;NOTE: The basic framework for this program was written several years ago
;when I was a rather inexperienced programmer and it probably shows in the
;code.  A lot of silly tricks were used to keep the code size to a minimum.
;Good luck to anyone attempting to modify it.
;
;EDITLI causes the system to enter an "edit" mode for all line-oriented
;keyboard input.  All of the VUE line-editing control characters are
;available.  Control-K as the very first character of a line causes the
;last line entered to appear.
;
;This program is invoked in the system initialization file with:
;
;       SYSTEM EDITLI.SYS/N
;
;Edit History:
;
;Revision         Date          Description
;--------       ---------       -----------
; 1.0(100)      16 Aug 84       Created
; 1.1(101)      10 May 85       Fixed inititalization so EDITLI works
;                               with other programs which fool with the
;                               monitor (e.g., TSASS, various CACHEs).
; 1.2(101)      20 May 85       Fixed problem with return from sys call
;                               skipping two bytes
;
; Flags in register D4:
;
B$INS = 0                       ; ^Q insert mode
B$SIL = 1                       ; Silent; set if KBD entered with echo
                               ; suppressed.
CH = 10
CI = 11
CK = 13
LF = 12
CL = 14
CR = 15
CQ = 21

VMAJOR = 1
VMINOR = 2
VSUB = 0
VEDIT = 101.
VWHO = 0

       SEARCH  SYS
       SEARCH  SYSSYM
       SEARCH  TRM
       OBJNAM  .SYS                    ; output name is EDITLI.SYS

       ASECT
       .=50
EM1010:                                 ; address of EM1010 trap vector
       PSECT

;
;EDITLI: must point to the first byte of this program.
;
EDITLI:
       PHDR    -1,0,PH$REE!PH$REU

       TYPECR  (C) Copyright 1984 John Waycott - All rights reserved

       MOV     EM1010,A0               ; Get 1010 Emulation vector
20$:    TST     (A0)+                   ; locate vector table
       BNE     20$
       ADD     #<4-2>*2,A0             ; get KBD routine address in A0
       CLR     D7                      ; use D7 to prevent sign extension
       MOVW    @A0,D7
       MOV     D7,A0
;
; find the sequence
;       CALL ....
;       TSTB    @A0
;
; by looking for the TSTB @A0 instruction.  The call is to TIN, which gets
; the next character from the terminal.
;
10$:    CMPW    (A0)+,#045020           ; is this the TSTB @A0 instruction?
       BNE     10$
;
; replace the sequence with a JMP.L KBD instruction.  We can do this
; because at this point, our routine can handle the keyboard input.
;
       LEA     A6,KBD
       MOV     A6,-(A0)                ; store <KBD> as jmp.l operand
       MOVW    #^H4EF9,-(A0)           ; store <jmp.l>
       EXIT

;
; This is the KBD routine.  Upon entry to this routine, A5 points to
; the terminal definition unit. A0 point to the JCB of the job.
; The keyboard routine has saved A0,A1,A3,A5,D1 on the stack.
;
; The system monitor handles the KBD call if:
;       1. the keyboard is in image or data mode
;       2. a command file is active, and the next line is not a :K
;       3. a terminal is attached.
;
KBD:    SAVE    A4,D0,D2,D3,D4,D5       ; save remaining registers
       MOV     T.ILB(A5),A3            ; set line buffer address
       MOV     A3,A4                   ; set addr of last byte in buffer
       ADD     T.ILS(A5),A4
       SUB     #4,A4                   ;   less CRLF and NULL terminators
       CLRB    @A4                     ; insure reasonable data
       PUSH    D1
       MOVB    #CQ,D1                  ; force ^Q to revive any ^S set.
       TRMICP
       POP     D1
       CLR     D4                      ; clear flags
       MOVW    #T$ECS,D7               ; set B$SIL if T$ECS is set.
       ANDW    @A5,D7
       BEQ     2$
       BSET    #B$SIL,D4
2$:     ORW     #T$IMI!T$ECS,@A5        ; set image mode, suppress echo
1$:     TSTB    T.STS(A5)               ; wait until all output flushed.
       BMI     1$

       MOVW    T.POO(A5),D3            ; set beginning position.
       MOVW    D3,D2                   ; set current position.
       MOV     A3,A2                   ; set buffer pointer
       TIN
       CMPB    D1,#CK
       BEQ     ISCK
       CLRB    @A2                     ; not control-K - clear buffer
       BR      NXT1
ISCK:   CALL    PAINT
NXT:    TIN                             ; get next character
NXT1:   TSTB    @A0                     ; check for interrupt
       JMI     C
       CMPB    D1,#127.                ; check for DEL
       JEQ     DEL
       CMPB    D1,#40                  ; printable?
       BLT     CCHAR                   ;   no
       BCALL   PRINT
       BR      NXT

;
; character is a control character
;
CCHAR:  ADD     D1,D1
       BEQ     NXT
       LEA     A6,10$[~D1]             ; table jump to appropriate routine
       ADDW    @A6,A6
       CALL    @A6
10$:    BR      NXT
       OFFSET  A
       OFFSET  RETURN
       OFFSET  RETURN
       OFFSET  D
       OFFSET  RETURN
       OFFSET  F
       OFFSET  RETURN
       OFFSET  H
       OFFSET  F                       ; TAB always inserts.
       OFFSET  J
       OFFSET  RETURN
       OFFSET  L
       OFFSET  M
       OFFSET  N
       OFFSET  RETURN
       OFFSET  RETURN
       OFFSET  Q
       OFFSET  R
       OFFSET  RETURN
       OFFSET  RETURN
       OFFSET  U
       OFFSET  V
       OFFSET  W
       OFFSET  RETURN
       OFFSET  Y
       OFFSET  Z
       OFFSET  RETURN
       OFFSET  RETURN
       OFFSET  RETURN
       OFFSET  RETURN
       OFFSET  RETURN

;
; printable character.  If printing over a TAB, insert the character.
;
PRINT:  CMPB    @A2,#CI
       BEQ     5$
       BTST    #B$INS,D4               ; check for insert mode
       BEQ     10$
5$:     PUSHW   D1
       CLRB    D1                      ; insure space insert.
       CALL    F
       RESTW   D1
       BNE     99$
10$:    CMP     A2,A4
       BEQ     99$
       CALL    OUTCH
       TSTB    @A2                     ; if at end of line, append a NULL
       BEQ     20$
       MOVB    D1,(A2)+
       RTN
20$:    MOVB    D1,(A2)+
       CLRB    @A2
       RTN
99$:    MOVB    #7,D1
       CALL    PUTC
RETURN: RTN

;
; DEL - delete character
;
DEL:    CMP     A2,A3                   ; if at BOL, do nothing
       BEQ     99$
       BTST    #B$INS,D4
       BEQ     20$
10$:    CALL    H
15$:    BCALL   D
       JMP     NXT
20$:    TSTB    @A2
       BEQ     10$
       CALL    H
       CMPB    @A2,#CI
       BEQ     15$
       MOVB    #40,@A2
       BTST    #B$SIL,D4               ; don't display if silent
       BNE     99$
       TTYI
       BYTE    ' ,CH,0,0
99$:    JMP     NXT


;
; delete word.
;
V:      CALL    NXTWRD
       CMP     A1,A2
       BEQ     D.X
       BR      DELBCH
;
; delete character at cursor.
;
D:      TSTB    @A2
       BEQ     D.X
       LEA     A1,1(A2)

DELBCH: PUSH    A2                      ; put current position on stack.
       CALL    LASTP
       POP     A6                      ; put current position in A6.
10$:    MOVB    (A1)+,(A6)+             ; move block of bytes down.
       BNE     10$
       CALL    REDRAW                  ; redraw the line.
D.X:    RTN

;
; clear line
;
Z:      BCALL   U
       BCALL   Y
       RTN
;
; Delete to end of line.
;
Y:      CALL    LASTP                   ; get last position.
       CLRB    @A2                     ; clear rest of line.
       CALL    REDRAW                  ; redraw the line.
       RTN

;
; go to beginning of line
;
U:      BCALL   H
       BNE     U
       RTN

;
; backspace
; z-bit is set if beginning of line.
;
H:      CMP     A2,A3                   ; check if at beginning
       BEQ     99$
       DEC     A2
       CALL    BCK
       LCC     #0
99$:    RTN

;
; move to end of line
;
N:      BCALL   L
       BNE     N
       RTN

;
; forward space
; z-bit set if end of line.
;
L:      TSTB    @A2
       BEQ     99$
       CALL    FWD
       INC     A2
       LCC     #0
99$:    RTN

;
; Repaint line
; Entry PAINT is called when an up-arrow is first entered.
; It repaints the line and removes the CRLF.
;
R:      BCALL   N
       TYPECR  ^R
       CLR     D3                      ; clear beginning position
       CLRW    D2                      ; clear current position
       MOV     A3,A2
PAINT:  MOVB    @A2,D1
       BEQ     99$
       CMPB    @A2,#CR
       BEQ     99$
       CMPB    @A2,#LF
       BEQ     99$
       CALL    OUTCH
       INC     A2
       BR      PAINT
99$:    CLRB    @A2
       RTN

;
; interrupt - clear buffer and return
;
C:      CLRB    @A3
       BR      DONE1
;
; end of line - carraige return or line feed.
;
; If we have a carraige return, look to see if a line feed is the next
; character waiting.  If so, discard it.  This prevents a type-ahead
; problem when entering multiple lines, but does not allow a LF
; to be entered ater a CR before the computer is accepting input.
M:      TST     T.ICC(A5)       ; any type-ahead?
       BEQ     10$             ;   no
       MOV     T.IBF(A5),A6    ;   yes - discard if LF
       CMPB    @A6,#LF
       BNE     10$
       TIN
10$:    TSTB    (A2)+
       BNE     10$
       MOVB    #CR,-1(A2)
       BR      DONE
J:      TSTB    (A2)+
       BNE     J
       DEC     A2
DONE:   MOVB    #LF,(A2)+       ; store final LF and NULL
       CLRB    @A2
       TST     (SP)+           ; pop stack and echo CRLF
       CRLF
       MOVB    #LF,JOBCMS+1(A0); store LF in upper byte of JOBCMS word
10$:
;
;If input is in upper case, convert the string to upper case
;
       MOVW    @A5,D7
       ANDW    #T$ILC,D7
       BNE     DONE1
       MOV     A3,A2
20$:    MOVB    @A2,D1
       BEQ     DONE1
       UCS
       MOVB    D1,(A2)+
       BR      20$

DONE1:  ANDW    #~<T$IMI>,@A5           ; restore image mode
       BTST    #B$SIL,D4               ; restore echo if B$SIL is clear
       BNE     10$
       ANDW    #~<T$ECS>,@A5
10$:    MOV     A3,A2                   ; set return pointer
       ANDW    #~<C.KIN!C.PTL>,JOBCMS(A0) ; clear :K or :P in cmd file
       REST    A4,D0,D2,D3,D4,D5
       REST    A0,A1,A3,A5,D1          ; restore registers from sys call
       RTE                             ; return from system call

;
; Toggle insert mode
;
Q:      BCHG    #B$INS,D4
       MOVB    #7,D1
       CALL    PUTC
       RTN

;
; insert a space or tab in the line.
; If D1 is CI * 2, insert tab.
; If no room in buffer, z-bit is cleared.
;
F:      MOV     A2,A1                   ; find end of line
10$:    TSTB    (A1)+
       BNE     10$
       CMP     A1,A4
       BLO     20$
       LCC     #0                      ; clear z-bit - no room for insert
       RTN
20$:    MOVB    -(A1),1(A1)
       CMP     A2,A1
       BNE     20$
       MOVB    #40,@A2                 ; insert space or tab
       CMPB    D1,#CI_1
       BNE     30$
       MOVB    #CI,D1                  ; if tab insert, move past the tab.
       MOVB    D1,(A2)+
       CALL    OUTCH                   ; output the tab
30$:    CALL    LASTP                   ; repaint the line
       CALL    REDRAW
       LCC     #4                      ; return success.
       RTN

;
; Move cursor to beginning of word
;
A:      CALL    H                       ; backspace
       BEQ     99$                     ; at beginning of line
       ALF
       BEQ     20$
       NUM
       BNE     A
20$:    CALL    H
       BEQ     99$
       ALF
       BEQ     20$
       NUM
       BEQ     20$
       CALL    L
99$:    RTN

;
; move to next word
;
W:      BCALL   NXTWRD
10$:    CMP     A2,A1
       BHIS    99$
       CALL    L
       BR      10$
99$:    RTN


;
; nxtwrd - point a1 to the next word in the line.
;
NXTWRD: MOV     A2,A1                   ; save a2
10$:    TSTB    @A2
       BEQ     99$
       INC     A2
       ALF                             ; skip alphanumerics
       BEQ     10$
       NUM
       BEQ     10$
20$:    TSTB    @A2
       BEQ     99$
       CMP     A2,A4
       BEQ     99$
       INC     A2
       ALF
       BEQ     99$
       NUM
       BNE     20$
99$:    XCH     A1,A2                   ; restore a2 and set a1.
       RTN

;backspace the display.  If backspace is over a character, simply output
;a control-H to do the backspace.  If backspacing over a tab, calculate
; how many backspaces to actually do.
;
BCK:    CMPB    @A2,#CI                 ; if not tab, backspace.
       BEQ     10$
       MOVB    #CH,D1
       CALL    PUTC
       DECW    D2                      ; decrement position
       RTN
10$:    MOVW    D3,D0                   ; get beginning position count.
       MOV     A3,A6                   ; beginning of buffer
CHKTB:  CMP     A6,A2                   ; reached current character?
       BHIS    CHKTBX                  ;   yes
       CMPB    (A6)+,#CI               ; increment pos by tabstop if a tab.
       BEQ     10$
       INC     D0
       BR      CHKTB
10$:    ADD     #10,D0
       ANDW    #~7,D0
       BR      CHKTB
CHKTBX: SUBW    D2,D0
       NEGW    D0
       MOVB    #CH,D1                  ; output backspaces.
10$:    CALL    PUTC
       DECW    D2
       DECW    D0
       BGT     10$
99$:    RTN

;
; move cursor forward.
; If forward over tab, compute new position and output necessary spaces.
;
FWD:    MOVW    #1,D0                   ; default count
       CMPB    @A2,#CI
       BNE     OUTCL
10$:    MOVW    D2,D0                   ; get output position
       ANDW    #7,D0                   ; compute no. of spaces to output
       ADDW    #-10,D0
       NEGW    D0
OUTCL:  MOVB    #CL,D1
10$:    BCALL   PUTC
       INCW    D2
       DECW    D0
       BGT     10$
       RTN

;
;outch - output a character.  Adjust output position stored in D2.
;If outputting a TAB, output spaces to tab position.
;posch - does same but dows not write char to terminal.  Returns number
;of spaces moved in D7.
;
OUTCH:  BCALL   POSCH                   ; set position
       CMPB    D1,#CI                  ; if tab, output spaces, else
       BEQ     10$
       BCALL   PUTC
       RTN
10$:    MOVB    #40,D1
       PUSHW   D7
       BCALL   PUTC
       POPW    D7
       DECW    D7
       BGT     10$
       RTN

POSCH:  MOVW    #1,D7
       CMPB    D1,#CI
       BNE     99$
       MOVW    D2,D7
       ANDW    #7,D7
       ADDW    #-10,D7
       NEGW    D7
99$:    ADDW    D7,D2
       RTN

;
; putc - output character in D1 to terminal if echo is not suppressed.
;
PUTC:   BTST    #B$SIL,D4
       BNE     99$
       TTY
99$:    RTN

;
;lastp - returns the screen position of the last character on the line in d0.
;
LASTP:  MOV     A2,A6
       MOVW    D2,D0                   ; save current position
10$:    MOVB    (A6)+,D1
       BEQ     99$
       CALL    POSCH                   ; add to position
       BR      10$
99$:    XCH     D2,D0                   ; restore d2, d0 = last position.
       RTN

;
; redraw - redraw rest of line and clear end garbage.
; Called after a character or word delete.
; Upon entry, D2 contains current position, D0 contains the last position of
; the line before it was modified.
; The rest of the line is redrawn, and spaces are drawn to erase any garbage
; at the end.  Finally, the cursor is backed up to the original position.
;
REDRAW: SAVE    A2,D2
       CALL    PAINT                   ; paint the new line
10$:    CMPW    D2,D0                   ; at final position?
       BHIS    GOBACK                  ;   yes, go back again.
       MOVB    #40,D1                  ;   no, output a space.
       CALL    OUTCH
       BR      10$
GOBACK: REST    A2,D2                   ; restore original positions.
10$:    CMPW    D0,D2                   ; back to original?
       BLOS    99$                     ;   yes, all done.
       MOVB    #CH,D1                  ;   no, backspace.
       BCALL   PUTC
       DECW    D0
       BR      10$
99$:    RTN

       END

You are viewing proxied material from gopher.floodgap.com. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.