COMMENT ⊗   VALID 00011 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	.TITLE EDIT
C00003 00003	"EDIT"   - COMMAND INSTRUCTION
C00008 00004	"DEFPRO" - COMMAND INSTRUCTION
C00010 00005	"LOADP"  - COMMAND INSTRUCTION
C00013 00006	"SWITCH" - EDIT INSTRUCTION
C00014 00007	"DELETE" - EDIT INSTRUCTION
C00016 00008	"INSERT" - EDIT INSTRUCTION
C00018 00009	"PRINT"  - EDIT INSTRUCTION
C00020 00010	"SKIP"&"LAST" - EDIT INSTRUCTIONS
C00022 00011	"FILLI"  - EDIT SUBROUTINE
C00025 ENDMK
C⊗;
.TITLE EDIT

;POINTERS TO VARIABLES KEEP ON THE STACK

PPTR	==4 	;PTR TO CURRENT PROGRAM SYMBOL BLOCK
SNUM	==2 	;CURRENT STEP NUMBER
OPTR	==0	;PTR TO PREVIOUS STEP BLOCK

PPTR2	==MAXARG+6	;PTRS USED BY EDIT FUNCTIONS
SNUM2	==MAXARG+4
OPTR2	==MAXARG+2
;"EDIT"   - COMMAND INSTRUCTION
 
;THIS COMMAND IS USED FOR MODIFYING EXISTING MOTION INSTRUCTION
;STEPS.  THE REQUIRED ARGUMENTS FOR THIS ROUTINE ARE THE NAME
;OF THE MOTION PROGRAM TO BE EDITED AND THE INSTRUCTION LINE
;NUMBER TO BEGIN WORK.  IF THE PROGRAM NAME IS OMITTED, THE
;PREVIOUS PROGRAM NAME IS USED.  IF IN ADDITION, THE LINE NUMBER
;IS OMITTED, EDITING WILL PICK UP FROM THE POINT WHERE EDITING
;WAS LAST TERMINATED.

;REGISTERS USED:
;	ALL REGISTERS ARE AVAILABLE FOR USE

EDIT:	SUB	#6,SP		;MAKE ROOM FOR PROG/STEP INFO
	MOV	@#EDSNUM,R3	;PREVIOUS STEP NUMBER
	MOV	(R4)+,R0	;PICK UP PROGRAM NAME
	BNE	EDIT1
	MOV	@#EDPROG,R0	;USE SAME PROGRAM AS LAST TIME
	BNE	EDIT2
	MOV	#NOPROG,R1	;SIGNAL ERROR IF NOT DEFINED
	JSR	PC,TYPERR
	BR	EDTEXX
EDIT1:	MOV	#1,R3		;DEFAULT STEP = 1
EDIT2:	MOV	(R4),R2		;PICK UP LINE NUMBER
	BGT	EDIT3
	MOV	R3,R2		;USE DEFAULT OR OLD VALUE

;SWITCH START EXECUTION FROM HERE

EDIT3:	MOV	R0,@#LPROG	;USE THIS PROGRAM'S LABEL LIST
	MOV	#EDTMES,SG	;TYPE PROGRAM NAME
	JSR	PC,TYPSTR
	MOV	#OUTBUF,SG
	JSR	PC,PACNMS
	MOV	#OUTBUF,SG
	JSR	PC,LINOUT
	MOV	R0,PPTR(SP)	;INITIALIZE PROG/STEP INFO
	MOV	R0,OPTR(SP)
	MOV	#1,SNUM(SP)
	DEC	R2		;ADVANCE TO PROPER STEP NUMBER
	BNE	MVEDWN
EDITLP:	MOV	SNUM(SP),R0	;PRINT THE CURRENT MOTION INST.
	MOV	@OPTR(SP),R1
	JSR	PC,PSTEP
	MOV	#OUTBUF,SG	;STEP NUMBER STILL IN OUTBUF
	MOVB	#77,5(SG)	;TYPE "STEP NUMBER?"
	CLRB	6(SG)
	JSR	PC,TYPSTR
	MOV	#INBUF,SG	;READ IN THE RESPONSE
	JSR	PC,INSTR
	MOV	#MOTION,R2	;ASSUME MOTION INST TYPED
	JSR	PC,GETLBL	;CHECK FOR MOTION INST LABEL
	BCC	EDIT4
	TST	R1		;ILLEGAL LABEL?
	BNE	EDITER		;YES
	BIS	#EDITIN,R2	;NO LABEL: EDIT OR MOTION INST?
EDIT4:	MOV	R0,R4		;SAVE LABEL VALUE
	MOV	#FUNTAB,R0	;DECODE RESPONSE
	MOV	R2,R1
	JSR	PC,PUSARG
	BCC	EDIT5		;BRANCH IF DECODED PROPERLY
	TST	R1		;GO TO NEXT LINE IF C/R TYPED
	BNE	EDITER
	MOV	#BADLIN,R1	;ERROR IF LABEL JUST TYPED
	TST	R4
	BEQ	NXTLNE
EDITER:	JSR	PC,TYPERR	;ELSE INPUT ERROR
	BR	EDITLP

EDIT5:	CMPB	#EDITIN,TYPBIT(R0)	;EDIT INSTRUCTION?
	BNE	EDIT6
        JSR	PC,@(R0)+	;EXECUTE EDIT FUNCTION
	ADD	#MAXARG,SP	;CLEAR ARGUMENT LIST
	BR	EDITLP
EDIT6:	MOV	R0,-(SP)	;SAVE NEW MOTION INST PTR
	MOV	@OPTR2(SP),R0	;PTR TO OLD MOTION INSTRUCTION
	BEQ	EDIT7
	MOV	(R0),@OPTR2(SP)	;DELETE OLD INSTRUCTION STEP
	JSR	PC,CLRLBL
	JSR	PC,RELBLK
EDIT7:	MOV	(SP)+,R0	;CREATE NEW INSTRUCTION BLOCK
	MOV	R4,R1		;LABEL
	JSR	PC,FILLI
	ADD	#MAXARG,SP	;CLEAR ARGUMENT LIST
	BR	EDITLP
NXTLNE:	MOV	#1,R2		;MOVE TO NEXT LINE
MVEDWN:	TST	@OPTR(SP)	;END OF PROGRAM?
	BEQ	EDITLP		;YES
	MOV	@OPTR(SP),OPTR(SP)	;NO, MOVE TO NEXT STEP
	INC	SNUM(SP)
	SOB	R2,MVEDWN
	BR	EDITLP

TERMIN:	ADD	#MAXARG+2,SP		;CLEAR SUBR. ARGUMENTS
EDTDNE:	MOV	PPTR(SP),@#EDPROG	;SAVE PROGRAM AND STEP NUMBER
	MOV	SNUM(SP),R0		;RESTART AT CURRENT STEP-1
	DEC	R0
	BGT	.+6
	MOV	#1,R0
	MOV	R0,@#EDSNUM
EDTEXX:	ADD	#6,SP
       	RTS	PC

EDTMES:	.ASCIZ	/EDITING USER PROGRAM /
	.EVEN

;END OF "EDIT"
;"DEFPRO" - COMMAND INSTRUCTION
 
;THIS COMMAND IS USED FOR READING IN A MOTION PROGRAM THAT HAS
;BEEN DUMPED OUT.  IT REQUIRES AS ITS ONLY ARGUMENT A POINTER
;TO A USER PROGRAM SYMBOL BLOCK.  IF THE USER PROGRAM ALREADY
;HAS SOME STEPS DEFINED, ALL EXISTING STEPS ARE DELETED BEFORE
;THE NEW PROGRAM IS READ.

;REGISTERS USED:
;	ALL REGISTERS ARE AVAILABLE FOR USE

DEFPRO:	MOV	(R4),R3		;PICK UP PROGRAM NAME
	MOV	R3,-(SP)	;INITIALIZE PROG/STEP INFO
	MOV	#1,-(SP)
	MOV	R3,-(SP)
	TST	(R3)		;PROGRAM STEPS ALREADY DEFINED?
	BEQ	DEFPR1		;NO
	BR	DEFDL2		;DELETE ALL EXISTING STEPS
DEFDL1:	MOV	R3,R0
	JSR	PC,RELBLK
DEFDL2:	MOV	(R3),R3		;DELETE ONE STEP
	BNE	DEFDL1		;END OF PROGRAM?
	CLR	@OPTR(SP)
DEFPR1:	MOV	#INBUF,SG	;READ IN A STEP
	JSR	PC,INSTR
	JSR	PC,GETINT	;STRIP OFF LINE NUMBER
	BCC	DEFPR2
	TST	R1
	BNE	DEFPER
DEFPR2:	MOV	#FUNTAB,R0	;DECODE RESPONSE
	MOV	#MOTION,R1	;MOTION INSTRUCTION?
	JSR	PC,PUSARG
	BCS	DEFPR3		;BRANCH IF DECODED IMPROPERLY
	JSR	PC,FILLI
	ADD	#MAXARG,SP	;CLEAR ARGUMENT LIST
	BR	DEFPR1
DEFPR3:	TST	R1
	BEQ	DEFPDN		;EMPTY LINE MARKS END
DEFPER:	JSR	PC,TYPERR	;TYPE ERROR MESSAGE
DEFPDN:	ADD	#6,SP		;CLEAR STACK
       	RTS	PC


;END OF "DEFPRO"
;"LOADP"  - COMMAND INSTRUCTION
 
;THIS COMMAND IS USED FOR READING IN A MOTION PROGRAM THAT HAS
;BEEN DUMPED OUT.  IT REQUIRES DOES NOT REQUIRE ANY ARGUMENTS
;IF THE USER PROGRAM ALREADY HAS SOME STEPS DEFINED, ALL EXISTING
;STEPS ARE DELETED BEFORE THE NEW PROGRAM IS READ.

;REGISTERS USED:
;	ALL REGISTERS ARE AVAILABLE FOR USE

LOADP:	MOV	#INBUF,SG	;READ A LINE FROM THE HSR
	JSR	PC,HSR
	BCS	LODERR		;ABORTED?
	MOV	#KPROG,R0	;PICK UP PROGRAM NAME
	JSR	PC,GTOKEN
	BCC	1$
	TST	R1		;IGNOR EMPTY LINES
	BEQ	LOADP
	BR	LODERR		;ELSE MUST BE SYNTAX ERROR

1$:	JSR	PC,GETPRG	;GET THE PROGRAM NAME
	BCC	2$
	TST	R1		;SYNTAX ERROR?
	BNE	LODERR
	MOV	#NOPROG,R1	;MUST NOT BE A PROGRAM NAME
	BR	LODERR

2$:	MOV	#INBUF,SG	;TYPE THE PROGRAM NAME
	JSR	PC,LINOUT
	MOV	R0,R2		;SAVE PROGRAM NAME
	MOV	R2,-(SP)	;INITIALIZE PROG/STEP INFO
	MOV	#1,-(SP)
	MOV	R2,-(SP)
	TST	(R2)		;PROGRAM STEPS ALREADY DEFINED?
	BEQ	SAVPRO		;NO
	BR	4$		;DELETE ALL EXISTING STEPS
3$:	MOV	R2,R0
	JSR	PC,RELBLK
4$:	MOV	(R2),R2		;DELETE ONE STEP
	BNE	3$		;END OF PROGRAM?
	CLR	@OPTR(SP)

SAVPRO:	MOV	#INBUF,SG	;READ IN A STEP
	JSR	PC,HSR
	BCS	SAVDNE
	JSR	PC,GETINT	;STRIP OFF LINE NUMBER
	BCC	1$
	TST	R1
	BNE	3$		;SYNTAX ERROR
1$:	MOV	#FUNTAB,R0	;DECODE RESPONSE
	MOV	#MOTION,R1	;MOTION INSTRUCTION?
	JSR	PC,PUSARG
	BCS	2$		;BRANCH IF DECODED IMPROPERLY
	JSR	PC,FILLI
	ADD	#MAXARG,SP	;CLEAR ARGUMENT LIST
	BR	SAVPRO

2$:	TST	R1		;EMPTY LINE MARKS END
	BEQ	4$
3$:	JSR	PC,TYPERR	;NON-FATAL ERROR
	MOV	#INBUF,SG
	JSR	PC,LINOUT
	BR	SAVPRO

4$:	MOV	#GOODLD,R1
SAVDNE:	ADD	#6,SP		;CLEAR STACK

LODERR:	JSR	PC,TYPERR
	RTS	PC


;END OF "LOADP"
;"SWITCH" - EDIT INSTRUCTION

;THIS FUNCTION SWITCHES THE USER PROGRAM BEING EDITED.  IT REQUIRES A
;POINTER TO THE SYMBOL BLOCK FOR THE NEW USER PROGRAM AND AN OPTIONAL
;STARTING LINE NUMBER.

;REGISTERS USED:
;	R0,R1,R2,R3 ARE GARBAGED

SWITCH:	MOV	2(SP),R0	;NEW PROGRAM
	MOV	4(SP),R2	;STARTING LINE NUMBER
	BGT	.+6
	MOV	#1,R2		;DEFAULT = STEP 1
	ADD	#MAXARG+2,SP	;CLEAR ARGS AND RET. ADDR
	JMP	EDIT3		;RESTART EDIT PROGRAM

;END OF "SWITCH"
;"DELETE" - EDIT INSTRUCTION

;THIS FUNCTIONS DELETES AN ARBITRARY NUMBER OF MOTION INSTRUCTIONS
;STARTING WITH THE CURRENT LINE.  IT REQUIRES AS ITS ONLY ARGUMENT A
;COUNT OF THE NUMBER OF LINES TO DELETE. IF THE COUNT IS NEGATIVE,
;NO DELETING IS DONE.

;REGISTERS USED:
;	R0,R1,R2,R3 ARE GARBAGED

DELETE:	MOV	2(SP),R2	;NUMBER OF STEPS TO DELETE
	BLT	DELTXX		;EXIT IF # < 0
	BNE	.+6
	MOV	#1,R2		;DEFAULT IS ONE STEP
	MOV	@OPTR2(SP),R3	;PTR TO CURRENT STEP
DELE1:	MOV	R3,R0		
      	BEQ	DELTDN		;ALL DONE IF END OF PROG
	MOV	(R3),R3		;DELETE ONE STEP
	CMP	R0,@SUBPTR	;DELETING NEXT STEP TO EXECUTE?
	BNE	.+6
	MOV	R3,@SUBPTR	;YES, MOVE UP POINTER
	JSR	PC,CLRLBL
	JSR	PC,RELBLK
	SOB	R2,DELE1	;REPEAT TILL DONE
DELTDN:	MOV	R3,@OPTR2(SP)	;SAVE NEW CURRENT STEP
DELTXX:	RTS	PC


;END OF "DELETE"
;"INSERT" - EDIT INSTRUCTION

;THIS EDIT FUNCTION ALLOWS THE USER TO INSERT AN ARBITRARY NUMBER OF
;NEW MOTION INSTRUCTIONS IN BETWEEN EXISTING INSTRUCTIONS.  NO
;ARGUMENTS ARE REQUIRED BY THIS ROUTINE OTHER THAN THE POINTERS SET
;UP ON THE STACK BY "EDIT".  THIS MODE IS TERMINATED BY TYPING ANY
;ILLEGAL MOTION INSTRUCTION OR AN EMPTY LINE.

;REGISTERS USED:
;	R0,R1,R2 GARBAGED

INSERT:	MOV	SNUM2(SP),-(SP)	;COPY CURRENT LINE # AND PTR
	MOV	SNUM2(SP),-(SP)
INSTLP:	MOV	#OUTBUF-2,SG	;TYPE THE CURRENT LINE NUMBER AND ?
	MOV	SNUM(SP),R0	;STEP NUMBER
	JSR	PC,PRTINT
	MOVB	#'?,(SG)+	;"?"
	CLRB	(SG)
	MOV	#OUTBUF,SG
	JSR	PC,TYPSTR
	MOV	#INBUF,SG	;READ IN A MOTION INSTRUCTION
	JSR	PC,INSTR
	JSR	PC,GETLBL	;CHECK FOR MOTION INST LABEL
	BCC	INSRT1
	TST	R1		;ILLEGAL LABEL?
	BNE	INSRER		;YES
INSRT1:	MOV	R0,R4		;SAVE LABEL VALUE
	MOV	#FUNTAB,R0	;DECODE MOTION INSTRUCTION
	MOV	#MOTION,R1
	JSR	PC,PUSARG
	BCS	INSRDN 		;BRANCH IF NOT
	MOV	R4,R1		;LABEL
	JSR	PC,FILLI	;INSERT THE NEW INSTRUCTION
	ADD	#MAXARG,SP	;CLEAR ARGS
	BR	INSTLP
INSRDN:	TST	R1		;EMPTY LINE?
	BEQ	.+6
INSRER:	JSR	PC,TYPERR	;NO, INPUT ERROR OCCURRED
	MOV	(SP)+,SNUM2(SP)	;SAVE NEW CURRENT LINE # AND PTR
	MOV	(SP)+,SNUM2(SP)
	RTS	PC

;END OF "INSERT"
;"PRINT"  - EDIT INSTRUCTION

;THIS EDIT FUNCTION PRINTS OUT AN ARBITRARY NUMBER OF STEPS OF A
;USER MOTION PROGRAM.  IT REQUIRES AS ITS ONLY ARGUMENT A COUNT
;OF THE NUMBER OF STEPS TO BE PRINTED.  AFTER EXECUTION, THE 
;CURRENT LINE POINTER IS LEFT POINTING AT THE LAST STEP PRINTED.

;REGISTERS USED:
;	R0,R1,R2 GARBAGED

PRINT:	MOV	2(SP),R2	;NUMBER OF LINES TO PRINT
	BLT	PRNTDN		;NOTHING TO DO IF COUNT < 0
	BNE	.+6
	MOV	#1,R2		;DEFAULT IS PRINT 1 STEP
	BR	PRNSTR
PRNTLP:	MOV	SNUM2(SP),R0	;ELSE PRINT THE STEP
	JSR	PC,PSTEP
PRNSTR:	MOV	@OPTR2(SP),R1	;AT LAST STEP?
	BEQ	PRNTDN		;CANT MOVE PAST LAST STEP
	MOV	R1,OPTR2(SP)	;ELSE MOVE ON TO NEXT STEP
	INC	SNUM2(SP)
	MOV	(R1),R1		;IS THIS THE LAST STEP?
	BEQ	PRNTDN		;YES
	SOB	R2,PRNTLP	;PRINTED ALL REQUESTED STEPS?
PRNTDN:	RTS	PC
	

;END OF "PRINT"
;"SKIP"&"LAST" - EDIT INSTRUCTIONS

;THE FOLLOWING EDIT FUNCTIONS ARE USED FOR MOVING THE CURRENT LINE
;POINTER FORWARD AND BACKWARD THROUGH THE USER PROGRAM.  "LAST"
;DECREMENTS THE MOTION STEP POINTER AND REQUIRES NO ARGUMENT.  "SKIP"
;MOVES THE CURRENT LINE POINTER TO AN ARBITRARY STEP NUMBER.  "SKIP"
;REQUIRES AS ITS ONLY ARGUMENT, A LINE NUMBER.  BOT ROUTINES
;MODIFY THE "EDIT" POINTERS ON THE STACK.

;REGISTERS USED:
;	R1,R2 GARBAGED

LAST:	MOV	#-1,R2		;MOVE STEP POINTER BACK ONE
	BR	MOVBCK

SKIP:	MOV	2(SP),R2	;GET NUMBER OF STEPS TO SKIP
	SUB	SNUM2(SP),R2
	BEQ	SKIPDN		;NOTHING TO DO IF ZERO
	BGT	FORWRD
MOVBCK:	MOV	PPTR2(SP),OPTR2(SP) ;MOVING BACK, STEP FROM 0
	ADD	SNUM2(SP),R2	;NOW HOW MANY STEPS FORWARD?
	MOV	#1,SNUM2(SP)
	DEC	R2
	BLE	SKIPDN		;CANT BACK UP PAST STEP 1
FORWRD:	TST	@OPTR2(SP)	;CANT MOVE PAST LAST STEP
	BEQ	SKIPDN
	MOV	@OPTR2(SP),OPTR2(SP)	;MOVE DOWN A STEP
	INC	SNUM2(SP)
	SOB	R2,FORWRD
SKIPDN:	RTS	PC

;END OF "LAST"&"SKIP"
;"FILLI"  - EDIT SUBROUTINE

;INSERTS A MOTION INSTRUCTION BETWEEN THE LAST AND THE CURRENT STEPS.
;A POINTER TO THE MOTION INSTRUCTION SYMBOL BLOCK IS ASSUMED TO BE IN
;R0 AND THE ARGUMENTS ARE ASSUMED TO BE ON THE STACK.  A SAMPLE
;CALLING SEQUENCE FOLLOWS:
;
;			MOV	#MOTIONBLK,R0
;			MOV	#LABEL,R1	;=0 IF NO LABEL
;			JSR	PC,FILLI
;
;AFTER EXECUTION, THE "EDIT" POINTERS ON THE STACK ARE UPDATED TO
;POINT TO THE INSTRUCTION FOLLOWING THE NEW INSERTED STEP.

;REGISTERS USED:
;	R0,R1,R2,R3,R4,R5 GARBAGED

FILLI:	MOV	R0,R2		;SAVE PTR TO MOTION SYM. BLK
	MOV	SP,R3		;PTR TO ARGUMENTS
	TST	(R3)+
	MOVB	NUMARG(R0),R4	;NUMBER OF ARGUMENTS
	BEQ	SAVINS
	CMP	#STRING,FUNARG(R2)	;1 STRING ARG?
	BNE	SAVINS		;BRANCH IF NOT
	MOV	2(SP),R3	;COUNT THE NUMBER OF CHARS IN STG
CNTCHR:	INC	R4
	TSTB	(R3)+
	BNE	CNTCHR
	ASR	R4		;CONVERT TO WORD COUNT
	MOV	2(SP),R3	;START SAVING FROM HERE
SAVINS:	MOV	R4,R0		;# OF WORDS IN INST. BLOCK
	ADD	#2,R0
	MOV	R1,R5		;SAVE LABEL
	BEQ	5$		;IF LABELED, MULTIPLY DEFINED?
	TST	(R5)
	BEQ	5$
	MOV	#DUPLBL,R1	;INDICATE ERROR
	BR	FILERR
5$:	JSR	PC,GETBLK	;GET SOME STORAGE SPACE
	BCS	FILERR		;EXIT IF NONE LEFT
	MOV	@OPTR2(SP),(R0)	;LINK IN NEW STEP
	MOV	R0,@OPTR2(SP)
	MOV	R0,OPTR2(SP)
	INC	SNUM2(SP)	;INDICATE ONE MORE STEP
	MOV	R2,2(R0)	;SET PTR TO MOTION INST. BLK
	TST	R5		;LABELED STEP?
	BEQ	10$
	BIS	#1,2(R0)	;YES, MARK INSTRUCTION
	MOV	R0,(R5)		;AND SET LABEL POINTER
10$:	CMP	(R0)+,(R0)+
	ASL	R4		;ANY ARGUMENTS?
	BEQ	FILDNE
	MOVB	(R3)+,(R0)+	;SAVE THE ARGUMENTS
	SOB	R4,.-2
	BR	FILDNE

FILERR:	JSR	PC,TYPERR
FILDNE:	RTS	PC

;END OF "FILLI"