;*********
;        *
; BASIC3 *
;        *
;*********
;
;	PCK00 - GET A LINE FROM INPUT DATASET
;
; PACK - PCK00  GET A LINE FROM INPUT DATASET
; USE OLD DEVICE IF INITIALISED, OTHERWISE TERMINAL
;
;	PRNT00 - OUTPUT CHARACTER OR LINE
;
; PRINTC - PRNT00  OUTPUTS CHARACTER IN R2
; ON SAVE DEVICE IF INITED, OTHERWISE ON TERMINAL
;
;
;	CRLF00:
;	PRNT01: SUBROUTINE TO PRINT OUT A LINE BUFFER
; WHICH HAS BEEN ACCUMULATED
; ON ENTRY:
;	OTPT IS PTR TO DEVICE FOR PRINT
; ON EXIT:
;	LINE PRINTED
;	BUFFER PTRS INITIALIZED
; REGISTERS USED: NONE
;
;	BREAK - WRITE PASS ALL COMMAND
;	CLOS00 - CLOSE OPEN DATA SET (NON USER DATA)
;
; CLOSEF - CLOS00  CLOSES ANY OPEN DATA SETS
;
;	CLEAR0 - CLEAR USER DATA AREA
;	CSINT0 - SET UP FOR COMMAND STRING INTERPRETER
; CSINT0 - COMMAND STRING INTERPRETER ROUTINE
; ON ENTRY:
;	R0: ZERO IF NO STRING TO INTERPRET
;	R2: ADDRESS OF SWITCH TABLE
;	R3: ADDRESS OF STRING
;	R4: LENGTH OF STRING
;
;	TST00 - TEST ALPHABETIC VS NUMERIC CHARACTER
;
; TSTCH - TST00, TEST ALPHABETIC VS NUMERIC IN R2
;	REGISTERS USED - R2
;	'V' SET IF NEITHER ALPHA OR NUMERIC
;	'Z' SET IF NUMERIC
;
;	PRN00 - PRINT A LINE OF ASCII
;
; PRINTL - PRN00 - PRINT A LINE OF ASCII
;	R0 HAS STARTING ADDRESS, LINE IS TERMINATED BY A ZERO BYTE
;	REGISTERS USED - R0,R2.

;
;
;	SKIP00 - GET NEXT NON-BLANK CHARACTER IN BUFFER
;
; SKIP - SKIP00, SKIP OVER BLANKS IN WORKING STORAGE, R1 POINTS
;  TO LINE POSITION, CHARACTER FOUND GOES TO R2
;	REGISTERS USED - R1,R2.
;
;	JUNK00 - SKIP OVER REMAINDER OF LINE
;
; JUNKIT - JUNK00, SKIP OVER REMAINDER OF LINE
;	UNTIL STATEMENT TERMINATOR IS FOUND (S.EOS OR HIGHER)
;  R1 POINTS TO TERMINATOR ON EXIT.
;	REGISTERS USED - R1.
;
;	CLRU00 - CHECK FOR AND DELETE USER SPACE
;
; CLRUSR - CLRU00, CHECK FOR EXISTENCE OF USER SPACE, AND DELETE
;  IT IF PRESENT.  REGISTERS USED - R5.
;
;	PUSH00 - PUSH ONE WORD IN R0 ONTO USER LIST
;
; PUSH - PUSH00, PUSH ONE WORD IN R0 ON USER STORAGE LIST
;	IF ENDTXT=0 ON ENTRY, SAVE R5 IN ENDTXT FIRST
;	IF R5 IS ODD, MOVE TO NEXT EVEN BOUNDARY
;	R5 IS UPDATED WHEN ITEM IS PLACED ON THE LIST
;	REGISTERS USED - R0,R5.
;
;	SRL00 - SEARCH USER STORAGE (FOR ITEM OF CLASS TYPE IN R4)
;
; SRLST - SRL00, SEARCH USER STORAGE FOR THE FIRST ITEM HAVING THE
;	CLASS AS SPECIFIED IN R4.  THE ADDRESS OF THE FOUND ITEM IS
;	RETURNED IN R3.  UPON ENTRY, R3 MUST POINT TO THE START ADDRESS
;	OF THE LIST.  REGISTERS USED - R0,R2,R3,R4.
;	AND R0 IS A MASK OF BITS TO IGNORE IN THE HEADER.
;
;	ARYL00 - COMPUTE NUMERIC ARRAY LENGTH
;
; ON ENTRY:
;	R0 HAS DATA TYPE (0=REAL*4, 2=INTEGER*2, 4=BYTE)
;	R3 POINTS TO CURRENT DATA ITEM
;
; ON EXIT:
;	R0 HAS LEN OF ITEM ROUNDED UP, BUT EXCLUDING HEADER
;	R3 AS ABOVE
;
; OTHER REGISTERS USED: R1
;
;
;	STRL00 - COMPUTE LENGTH OF STRING DATA ITEM
;
; ON ENTRY:
;	R0 HAS INDIVIDUAL STRING LENGTH
;	R1 HAS PACKED DIMENSIONS
;
; ON EXIT:
;	R0 HAS TOTAL LENGTH OF STRING ROUNDED UP, BUT EXCLUDING HEADER

;
;	SCR00 - DELETE BYTES FROM R3 TO R4 FROM USER STORAGE
;
; SCRNCH - SCR00, DELETE THE NUMBER OF BYTES FROM THE USER STORAGE
;	SPECIFIED BY R4.  R3 POINTS TO STARTING POINT FOR THE
;	DELETION.  REGISTERS USED - R2,R3,R4
;
;	SQU00 - DELETE ONE LINE OF TEXT
;
; SQUISH - SQU00, DELETE LINE WHOSE HEADER IS POINTED TO BY R5
; ON ENTRY:
;	R5 HAS POINTER TO LINE HEADER
; ON EXIT:
;	R5 = OLD R5 + 4 (POINTS TO PRECEDING LINE HEADER)
;	R1 POINTS TO INSERTION POINT FOR NEW LINE (WHERE OLD LINE WAS)
;	OLD LINE HEADER AND LINE TEXT ARE DELETED
;	ENDTXT AND BOLNHD UPDATED
;
;	SRCH00 - SEARCH FOR EOL
;
; SRCHLF - SRCH00, SEARCH FOR EOL, POINTER IN R1, WHEN DONE R1
;  POINTS ONE BYTE AFTER THE EOL.  REGISTERS USED - R1.
;
;	FIND00 - SEARCH TEXT FOR LINE NUMBER (SPECIFIED IN R0)
;
; FINDLN - FIND00
; SUBROUTINE TO FIND A GIVEN LINE IN THE PROGRAM TEXT
; BY SEARCHING THROUGH LINE NUMBER HEADERS
; ON ENTRY:
;	R0 HAS REQUIRED LINE NUMBER
; ON EXIT:
;	R1 HAS ABSOLUTE START OF LINE IF MATCH
;	R1 HAS INSERTION POINT IN TEXT IF NO MATCH
;	R5 POINTS TO HEADER IF MATCH
;	R5 POINTS TO HEADER INSERTION POINT IF NO MATCH
;	'Z' SET IF MATCH
;	'Z' CLEAR IF NO MATCH
;	R0 UNCHANGED
; OTHER REGISTERS USED: R2
;
;	GETV00 - GET VARIABLE AND PACK INTO R4
;
; GETVAR - GETV00, GET A VARIABLE AND PACK IT IN TRUNCATED ASCII INTO
;	R4.  ON RETURN R4 HAS VARIABLE, R2 HAS NEXT CHARACTER.
;	REGISTERS USED - R1,R2,R4.
;
;	DIMC00 - CHECK RANGE OF DIMENSION (IN R0) 
;
; DIMCHK - DIMC00, MAKE SURE DIMENSION IN R0 IS IN BOUNDS 0 TO 255
;	REGISTERS USED - R0.

;	SAVE00 - LIST PROGRAM ON "SAVE" DATASET
;
;	OLD00 - RESTART ON OLD FILE
;
;	CHAIN0 - START EXECUTING NEW FILE WITH OLD DATA
;
;	OVERLAY - ADD PROGRAM LINES FROM FILE AND OPTIONALLY EXECUTE
;
;	TSTU00 - CHECK FOR USER STORAGE OVERFLOW
;
; TSTOK - TSTU00, CHECK FOR POSSIBLE USER STORAGE OVERFLOW
;  R0 HAS NUMBER OF BYTES TO ENTER.  REGISTERS USED - R0,R3,R4,R5.
;
;	SCRA00 - DELETE A FILE
;	FNAME - CHECK STRING EXPRESSION FOR FILE SPEC
; ON ENTRY R1 CONTAINS TEXT POINTER
; ON EXIT FOLLOWING REGISTER ASSIGNMENTS:
;	R0: ZERO IF NO STRING TO INTERPRET, OTHERWISE = OLD R1
;	R1: TEXT POINTER
;	R2: ZERO TO INDICATE NO SWITCH TABLE FOR CSI
;	R3: ADDRESS OF STRING IN STRING WORK AREA (FROM EVALS)
;	R4: LENGTH OF STRING IN STRING WORK AREA (FROM EVALS)
;
;	OPEN00: COMMAND PROCESSOR (FILE OPEN)
;	CLOS00 - USER FILE CLOSE ROUTINE
;
;
; ROUTINE DELFDB
; TO DELETE SPACE FOR BASIC FDB (INCL BUFFER AND POINTERS ETC.)
; ON ENTRY:
;	R3 POINTS TO FDB TO BE DELETED
; ON EXIT:
;	STUFDB,STGOSB,STFONX UPDATED
; REGISTERS USED: R0,R2
;
;
; ROUTINE SRCHFL - TO SEARCH FOR FILE WHOSE HEADER
; MATCHES R4 AND MASK TO IGNORE IN R0
; PTR TO FCB -> R3 IF FOUND, 0 OTHERWISE
;
; FNMBR/FNMB00 - PROCESS FILE NUMBER, SETUP FILE BLOCK POINTERS
;
;	PRLN00 - PRINT LINE NUMBER
;
; PRNTLN - PRLN00 - PRINT LINE NUMBER
;	REGISTERS USED - R0,R1,R2.
;
;	GET00 - GET LINE LIMITS FOR COMMAND (LIST OR DELETE)
;
; GET00 - GET LINE LIMITS FOR COMMAND (LIST OR DELETE)
; ON ENTRY:
;	R1 POINTS TO START OF PARAMETERS
; ON EXIT:
;	R1 POINTS PAST END OF THIS SET OF PARAMS
;	R3 HAS ADDRESS OF LOWEST LINE # HEADER IN RANGE
;	R4 HAS ADDRESS OF HIGHEST INCLUDED LINE # HEADER
;	'Z' SET IF NO LINES INCLUDED IN RANGE
; OTHER REGISTERS USED: R0,R2,R5 (ALL)

;
;
;	LIST00 - LIST THE SOURCE TEXT
;	REGISTERS USED - R1,R2,R3,R4,R5
;
;
; SUBROUTINE TO PRINT OUT LINE WHOSE HEADER
; IS POINTED TO BY R5
;
;	DEL00 - DELETE TEXT IN USER PROGRAM
;	REGISTERS USED - R0,R1,R2,R3,R4,R5.
;
;	INIT00, INIT02 - STATEMENT INTERPRETER
;
; PDP-11 BASIC - COMMAND/STATEMENT INTERPRETER
;	REGISTERS USED - R0,R1,R2,R3,R4,R5
;
;
;
;
;	ASSM00 - ASSEMBLE LINE OF USER CODE
;
; ASSEMBLE LINE OF CODE INTO WORKING STORAGE - TRANSFER TO USER AREA
;	REGISTERS USED - R0,R1,R2,R3,R4.
;
;
; NOW DEFINE THE VERBS AND THEIR ROUTINE ADDRESSES
;
;	SET - COMMAND TO SET UP MISCELLANEOUS SYSTEM CONDITIONS
;	EXIT STATEMENT (DOCUMENTATION)
;	ON ERROR GOTO
;	IF END - RESET END-OF-FILE ERROR ROUTINE ADDRESS
;	SINGLE LINE STEP INSTRUCTION
;	PROGRAM CONTINUE
;	SLEEP COMMAND
;	WAIT0 - WAIT COMMAND - SPECIFY TIMEOUT PARAMETERS
;	PRI00 - PRIORITY COMMAND
;	LOAD - USER ASSEMBLY SUBROUTINE LOAD
;
; FORMAT FOR BASIC LOADABLE SUBROUTINES:
; FIRST THREE WORDS:
;	.WORD	ID0001	;THESE THREE WORDS ARE FILLED IN BY GLOBAL SYMBOLS
;	.WORD	ID0002	;FROM A SYMBOL TABLE FOR BASIC, ENSURING CORRECT
;	.WORD	ID0003	;SYMBOL LINKAGES (OR ELSE ERROR MESSAGE).
; NEXT TWO WORDS ARE LENGTHS:
;	.WORD	??????	;LENGTH (IN BYTES) OF CODE PLUS ENTRY POINTS
;	.WORD	??????	;LENGTH (IN BYTES) OF ENTRY POINTS
;	.WORD	??????	;# OF ENTRY POINTS
; NEXT ENTRIES ARE THREE WORD BLOCKS DESCRIBING ENTRY POINTS
;	.RAD50	/NAME/	;TWO WORDS OF RAD50 ENTRY POINT NAME
;	.WORD	??????	;OFFSET FROM START OF CODE PROPER
; FINALLY, ONE WORD CONTAINING NUMBER OF WORDS OF CODE PROPER:
;	.WORD	??????	;LEN (IN WORDS) OF CODE PROPER
;
; NOTE: THESE MODULES MUST BE TASK BUILT WITH /-HD/-FP AND:
;	STACK=0
;	UNITS=0
;
; IN ADDITION POSITION INDEPENDENT CODING TECHNIQUES MUST BE USED IN
; WRITING THE CODE BECAUSE ITS POSITION IN THE INTERPRETER WILL VARY
; DEPENDING ON WHAT OTHER ROUTINES ARE LOADED.

;
;
;	UNLOAD - COMMAND TO UNLOAD ALL USER LOADED MACRO ROUTINES
;
; SLIDE UP ROUTINE SLUP
; TO MOVE A BLOCK OF WORDS FROM LOW TO HIGH MEMORY
; ON ENTRY:
;	R2 HAS START ADDRESS OF BLOCK
;	R3 HAS END ADDRESS (FIRST WORD PAST BLOCK)
;	R0 HAS # OF BYTES TO MOVE UP (ASSUMED EVEN)
; ON EXIT:
;	R2 HAS OLD START ADDRESS
;	R3 HAS OLD START ADDRESS
;	R0 UNCHANGED
; NO OTHER REGISTERS USED
;
;
; SLIDE UP ROUTINE SLUP01
; TO MOVE A BLOCK OF WORDS FROM LOW TO HIGH MEMORY
; ON ENTRY:
;	R2 HAS START ADDRESS OF BLOCK
;	R3 HAS END ADDRESS (FIRST WORD PAST BLOCK)
;	R4 HAS NEW END (TOP) ADDRESS
; ON EXIT:
;	R2 HAS OLD START ADDRESS
;	R3 HAS OLD START ADDRESS
;	R4 HAS NEW START ADDRESS
;
;
; SLIDE DOWN ROUTINE SLDN
; ON ENTRY:
;	R2 HAS START ADDRESS OF BLOCK
;	R3 HAS END ADDRESS
;	R0 HAS # OF BYTES TO MOVE
; ON EXIT:
;	R2 HAS OLD END
;	R3 HAS OLD END
;	R0 UNCHANGED
; NO OTHER REGISTERS USED
;
;
; SLIDE DOWN ROUTINE SLDN01
; ON ENTRY:
;	R2 HAS START ADDRESS OF BLOCK
;	R3 HAS END ADDRESS
;	R4 HAS NEW START
; ON EXIT:
;	R2 HAS OLD END
;	R3 HAS OLD END (UNCHANGED)
;	R4 HAS NEW END
;
;