FOCAL NOTES ON INTERNAL STRUCTURE RSX FOCAL IS AN ADAPTATION OF DOS INSTRUMENTATION FOCAL FOR USE UNDER THE RSX OPERATING SYSTEM. THIS MEANS BASICALLY V6 AND LATER OF RSX11D, THOUGH IT MAY WORK (AT LEAST A SUBSET) UNDER 11-M. IT IS A TRUE MULTI-USER INTERPRETER (WITH A FAIRLY LARGE PURE SECTION AND IMPURE SECTIONS CONTAINING USERS' FOCAL VARIABLES AND CODE) AND MUST HAVE THE ASSEMBLY PARAMETER "PGMSIZ" DEFINED WHEN ASSEMBLING FCLINI OR A DEFAULT BUFFER SIZE FOR FOCAL CODE AND VARIABLES WILL BE ASSIGNED (CURRENTLY 4000. WORDS) FOR EACH USER. THE INTERPRETER PROPER IS MOSTLY SHARED CODE, BUT THE FSRSZ$ MACRO IN FCLMAI MAY BE ALTERED TO ALLOW MORE OR FEWER OPEN FILES THAN THE CURRENT 6 MAXIMUM. DEFINING VARIOUS ASSEMBLY PARAMETERS IN ASSEMBLY IS OFTEN DESIRABLE FOR THOSE NEEDING ONLY A FOCAL LANGUAGE. RES$F DEFINED GIVES A RESIDENT VERSION, I.E., NON-OVERLAID. VARIOUS OTHER OPTIONS EXCLUDE (MOSTLY HARDWARE-DEPENDENT) FUNCTIONS IN FOCAL. THESE SHOULD BE FOUND IN THE FUNCTION TABLE IN FCLMAI AND DEFINED IF FOCAL IS NOT SET UP AS A PRIVILEGED TASK. IF FOCAL IS NON-PRIVILEGED, IT CANNOT DISCOVER ANY REAL BUS ADDRESSES (I.E., 18-BIT ADDRESSES) BUT FADR GIVES A 16-BIT ADDRESS ONLY. ALSO, REFERENCES TO THE EXTERNAL PAGE WILL GIVE SEGMENT FAULTS. THESE ARE GIVEN AS ERROR 09. THE FBUS AND FBUSH FUNCTIONS PERMIT ACCESS TO 18-BIT (OR 22-BIT) MEMORY ADDRESSES, BUT USERS OF FOCAL'S INTERRUPT HANDLING PROVISIONS SHOULD BE AWARE OF THE PROBLEMS ALLOCATING UNIBUS MAPPING REGISTERS ON 11/70 CPU'S. NOTE FINALLY THAT RSX FOCAL USES THE GCML$ FACILITY TO PERMIT 2 LEVELS OF INDIRECTION IF DESIRED. SINCE THE LIBRARY READ COMMAND IN THE DOS VERSION DUPLICATED THE ACTION OF INDIRECT INPUT FILES, THERE IS ONLY ONE LEVEL OF LIBRARY READ. HOWEVER, LIBRARY CLOSE INPUT (L C I) WILL DO A RCML$ TO RESET INPUT TO THE CONSOLE. OPERATE COMMANDS NOW ARE USEFUL ONLY FOR NONFILE DEVICES, AND LIBRARY OPEN AND LIBRARY WRITE/TYPE WORK AS IN THE DOS VERSION. THE PACK FUNCTION WORKS AND ALL "STANDARD" MATH FUNCTIONS WORK, BUT SOME SPECIAL CHARACTERS MAY NOT WORK, AND CONTROL-Z ON INPUT WILL GET FOCAL TO EXIT. THE MCR COMMAND MCR>FCL T 255+257 WILL LEAD TO FOCAL TYPING THE RESULT, 512.0000 AND THEN EXITING. THIS WORKS FOR ANY SINGLE LINE COMMANDS AND ALLOWS FOCAL TO DO QUICK CALCULATIONS WHERE DESIRED. IT USUALLY PAYS TO MAKE FOCAL A LOW-PRIORITY TASK SINCE IT CAN EASILY BECOME CPU BOUND AND IS NOT SUPER-FAST (TO PUT IT MILDLY.) EXTENDED RSX FOCAL IS SPECIALLY ADAPTED TO CONTROL FUNCTIONS FOR USER EQUIPMENT. HOWEVER, TO MAKE OPTIMAL USE OF IT, AND ESPECIALLY TO USE ITS INTEGER ARRAY DATA TYPE, IT WILL BE DESIRABLE FOR USERS TO HAVE SOME UNDERSTANDING OF ITS INTERNAL STRUCTURE, SINCE SOME FOCAL FUNCTIONS WILL HAVE TO BE CALLED BY MOST (OR INDEED ALL) USER-ADDED FUNCTIONS TO PERFORM THEIR TASKS. IT WILL BE USEFUL FOR THE READER TO HAVE A SOURCE LISTING OF FOCAL AT HAND FOR FURTHER EXAMPLES. 1. FOCAL'S FLOATING-POINT HANDLER FOCAL USES A NON-STANDARD FORM OF FLOATING-POINT NUMBER, WHICH MAKES IT NECESSARY TO USE THE FOCAL FLOATING-POINT FUNCTIONS FOR ALL OPERATIONS ON FLOATING-POINT NUMBERS. (THIS IS COMPARATIVELY SLOW AND WAS THE MOTIVATION FOR THE INTEGER DATA FORMAT.) THE FOLLOWING IS A DISCUSSION OF HOW TO DO SO. A. THE FLOATING ACCUMULATOR IN ALL FLOATING-POINT OPERATIONS, ONE OF THE OPERANDS IS ALWAYS THE FLOATING-POINT ACCUMULATOR (FLAC) AND THE RESULT OF ALL OPERATIONS IS ALWAYS STORED IN THE FLOATING ACCUMULATOR. THE FLAC IS A 3-WORD SIGNED TWO'S COMPLEMENT NUMBER AT ADDRESSES BE,HORD, AND LORD (THE EXPONENT, HIGH-ORDER MANTISSA, AND LOW-ORDER MANTISSA), VIZ: BE +- EXP HORD +- HIGH MANTISSA LORD LOW MANTISSA (N.B.--BE,HORD, AND LORD ARE THE NAMES USED IN FOCAL ITSELF TOO.) B. FLOATING-POINT ROUTINES INTERNALLY, FOCAL'S FPP USES A 16-BIT EXPONENT AND SIGNED DOUBLE-PRECISION ARITHMETIC. EXTERNALLY (THAT IS, TO THE REST OF FOCAL), IT CONVERTS DATA INTO A 2-WORD FORMAT THAT USES AN 8-BIT SIGNED EXPONENT (PERMITTING MAGNITUDES OF ABOUT 10^38) A LOW ORDER MANTISSA BYTE, AND THE SIGNED HIGH-ORDER MANTISSA. THIS 2-WORD FORMAT IS USED TO STORE VARIABLES. THE FLOATING-POINT PACKAGE CAN PERFORM THE FOLLOWING OPERATIONS: (NAMES ARE AS USED IN FOCAL ITSELF MOSTLY) FGET LOAD AN OPERAND INTO THE FLAC FPOW RAISE THE FLAC TO AN INTEGER POWER (USED IN EVALUATING SERIES) FML$ MULTIPLY THE FLAC BY THE OPERAND FDV$ DIVIDE THE FLAC BY THE OPERAND FAD$ ADD THE OPERAND TO THE FLAC FSB$ SUBTRACT THE OPERAND FROM THE FLAC FPUT STORE THE FLAC AT THE SPECIFIED ADDRESS FABS TAKE THE ABSOLUTE VALUE OF THE FLAC FSGN LEAVE FLAC=-1 IF FLAC<0, 0 IF FLAC=0, AND +1 IF FLAC>0 FINT CONVERT THE FLAC INTO AN INTEGER AND LEAVE THE RESULT IN R1 (R1=AC INSIDE FOCAL LISTING) FREAD CONVERT THE ASCII STRING POINTED TO BY "AXOUT" (R4?) INTO A FLOATING-POINT NUMBER IN FLAC FPRINT PRINT THE CONTENTS OF FLAC AS AN ASCII STRING FNG$ NEGATE THE FLAC FZER TO ZERO FLAC FCODE TO EXECUTE THE FLOATING-POINT INSTRUCTION IN R1 TO AVOID USING THE EMT TRAP, FOCAL USES THE ILLEGAL INSTRUCTION TRAP (LOSE!) TO COMMUNICATE WITH THE FLOATING-POINT HANDLER. THIS IS DONE BY CODING ALL TRAPS IN THE LOW ORDER BYTE OF A WORD AND ADDING 7000, MAKING UP THE ILLEGAL INSTRUCTION. THE LOW BYTE IS THEN DECODED BY FOCAL TO FIGURE OUT WHAT TO DO. THE CODES FOR FLOATING-POINT OPERATIONS ARE AS FOLLOWS OPERATION CODE COMPLETE INSTRUCTION --------- ---- -------- ------------ FGET 00 7000+00+ADDRESS CODE FAD$ 10 7000+10+ADDRESS CODE FSB$ 20 7000+20+ADDRESS CODE FDV$ 30 7000+30+ADDRESS CODE FML$ 40 7000+40+ADDRESS CODE FPOW 50 7000+50+ADDRESS CODE FPUT 60 7000+60+ADDRESS CODE FINT 71 7071 FSGN 72 7072 FABS 73 7073 FNG$ 74 7074 FREAD 75 7075 FPRINT 76 7076 FZER 77 7077 FCODE 200 7000+200 NOTE THAT THE SYMBOL "FPPTRP" IS GLOBAL AND A CALL OF THE FORM JSR PC,FPPTRP .WORD FINT ;FOR EXAMPLE--PUT ANY FLOATING POINT OPERATIONS HERE [.WORD ARG1,ARG2,ETC] ;IF REQUIRED FOR FPP OPERATIONS WILL PERFORM THE FLOATING POINT OPERATION WITHOUT THE OVERHEAD OF RSX TRAP HANDLING. THE ADDRESSING MODES AVAILABLE TO THE FPP AND THEIR CODES ARE THESE: MODE CODE MEANING DIRECT 0 THE ADDRESS OF THE OPERAND IS IN THE NEXT WORD (NON-POSITION-INDEPENDENT) IMMED 5 THE NEXT 2 WORDS ARE THE OPERAND (CODE AS FOLLOWS, FOR EXAMPLE: FPUT+IMMED;PUT IN NEXT 2 WORDS FOO: .WORD 0,0 ;TO REFER TO FOO LATER ) IPTR 1 THE ADDRESS OF THE OPERAND IS IN R2 (@R2) XPTR 2 R2 IS INCREMENTED BY 2 BEFORE BEING USED AS A POINTER TO THE OPERAND THROUGH STACK 4 THE TOP ELEMENT OF THE STACK IS THE ADDRESS OF THE OPERAND FROM STACK 3 THE OPERAND IS THE TOP 2 ELEMENTS OF THE STACK REL 6 THE NEXT WORD CONTAINS THE ADDRESS OF THE DATA IN RELATIVE MODE (PIC). (E.G. FPUT+REL,DEST-. . . . DEST: .WORD 0,0;SOMEWHERE ELSE IN PGM) NOTE THAT DIRECT, IMMEDIATE, AND RELATIVE MODES REQUIRE EXTRA WORDS IN LINE FOR THE ADDRESS OR OPERAND. IN DIRECT MODE, AN INSTRUCTION WOULD LOOK LIKE FML$+DIRECT,FLTONE IN RELATIVE MODE, AN INSTRUCTION MIGHT LOOK LIKE FML$+REL,FLTONE-. IN IMMEDIATE MODE, THE INSTRUCTION MIGHT LOOK LIKE FML$+IMMED FLTONE: .WORD 1,40000 ;FLOATING 1.0 STACK MODES (3 AND 4) DO NOT PUSH OR POP THE STACK; THIS IS UP TO THE USER, WHO SHOULD PUSH A PAIR OF LOCATIONS ON THE STACK BEFORE USE AND POP THE STACK WHEN DONE WITH THE RESULT. AS AN EXAMPLE, EVALUATE X^2+2X+1 WHERE R2 POINTS TO X: BEGIN: CMP -(SP),-(SP);OPEN STACK FZER STACK=0 FGET+IPTR FML$+IPTR ;X^2 FPUT+FROM+STACK ;SAVE ON STACK FGET+IPTR ;GET X AGAIN FML$+IMMED ;MULTIPLY BY 2 .WORD 2,40000 ;2.0 FAD$+IMMED ;ADD 1 .WORD 1,40000 ;1.0 FAD$+FROM+STACK ;ADD X^2. RESULT NOW IN FLAC CMP (SP)+,(SP)+ ;CLEAN UP STACK NOTE THAT USE OF THE STACK IS GOOD PRACTICE BECAUSE IT SAVES SPACE AND LENDS ITSELF TO RE-ENTRANCY IN FUNCTIONS. C. STANDARD SUBROUTINES A USER FUNCTION MAY CALL THE STANDARD FOCAL MATH SUBROUTINES FROM HIS NEW FUNCTION(S) BY PUTTING THE ARGUMENT WHERE THE STANDARD FUNCTION EXPECTS IT AND EXECUTING A JSR PC,FUNCTION FUNCTION START ADDRESS ARGUMENT ADDRESS FSIN FSIN FLAC FCOS FCOS FLAC FRAN XRAN FLAC (IF ANY) FCLK XFCLK NONE FSQT XSQT FLARG FLOG XFLOG FLAC FEXP XFEXP FLAC FATN XFATN FLAC FIOR OR FAND MAY NOT BE CALLED THIS WAY SINCE THEY HAVE MORE THAN 1 ARGUMENT. EXAMPLES MAY BE FOUND IN THE FOCAL LISTING. D. FOCAL SUBROUTINES FOR THOSE FUNCTIONS NOT USING THE FLOATING-POINT PACKAGE (LONG MAY THEY LIVE!) IT WILL BE USEFUL STILL TO BE ABLE TO CALL THE FOCAL INTERPRETER TO GET ARGUMENTS OR MANIPULATE TEXT. IN THE FOLLOWING, CHAR IS R4. IN THE SORTC AND TESTC DISCUSSION, "RETURN" MEANS THE ADDRESS TO TRANSFER TO IF CONDITIONS ARE MET,NOT ACTUAL INSTRUCTIONS OF SOME KIND. INTERNAL FUNCTIONS ARE IMPLEMENTED AS TRAP CALLS WITH THE FOLLOWING CODES AND MEANINGS: NAME CODE MEANING GETC 214 GET THE NEXT CHARACTER FROM THE TEXT; STORE INTO CHAR SORTC 202 COMPARE CONTENTS OF CHAR AGAINST LIST. CALL SEQUENCE: SORTC ;CALL .WORD LIST ;ADDRESS OF LIST .WORD RETURN ;RETURNS IF IN LIST (RETURNS TO NEXT INSTRUCTION IF NOT IN LIST) (N.B. LISTS ARE TERMINATED BY NEGATIVE NUMBERS) PRINTC 204 PRINT THE CONTENTS OF CHAR (7-BIT ASCII OR INTERNAL CODES FOR TEMINATORS) OUTC 210 PRINT 8-BIT ASCII IN CHAR READC 206 READ A CHARACTER FROM KB AND PUT INTO CHAR IN FOCAL INTERNAL CODE. INCH 212 READ 8-BIT ASCII AND PUT INTO CHAR SPNOR 234 IGNORE SPACES IN TEXT; RETURN WITH FIRST CHARACTER THAT ISN'T SPACE IN CHAR ERRORC 201+ERROR NO +ERROR NO. TRANSFER CONTROL TO ERROR ROUTINE, STOP EXECUTION AND PRINT ERROR MESSAGE OF ERROR NUMBER AND LINE. TESTC 220 A SERIES OF SORTC WITH VARIOUS RETURNS: CALL: TESTC ;CALL .WORD RETURN1 ;TEMINATOR .WORD RETURN2 ;NUMBER .WORD RETURN3 ;FUNCTION (CHAR=F) (RETURNS HERE IF ALPHABETIC CHARACTER IN CHAR) SORTJ 200 THIS IS A MULTIPLE SORT AND BRANCH. CHAR IS COMPARED TO A LIST. IF IT IS IN THE LIST, AN ADDRESS IS LOOKED UP AND AN EFFECTIVE JUMP TO THE ADDRESS IS EXECUTED. IF A MATCH IS NOT FOUND, THE RETURN IS TO CALL+6. CALL: SORTJ .WORD LISTCHAR ;CHARACTER LIST .WORD LISTADR ;ADDRSSS OF LIST OF ADDR (RETURNS HERE IF CHARACTER NOT IN LIST) EVAL.X 260 EVALUATES AN ARITHMETIC EXPRESSION. THE SUBROUTINE RETURN IS TO CALL+2 (I.E., THE WORD AFTER THE TRAP) WITH THE FLOATING POINT VALUE OF THE EXPRESSION EVALUATED INTO FLAC. E. PASSING ARGUMENTS ONE MAINLY USES THESE INTERNAL FOCAL FUNCTIONS TO PASS ARGUMENTS TO AN FNEW. WHEN A FUNCTION GAINS CONTROL, THE FIRST ARGUMENT IN THE ARGUMENT LIST IS EVALUATED IN THE FLAC ALREADY. IF ONLY 1 ARGUMENT IS NEEDED, THE FUNCTION NEED ONLY PERFORM ITS FUNCTION AND LEAVE THE RESULT IN FLAC, THEN RETURN VIA RTS PC. HOWEVER, MULTIPLE ARGUMENTS MAY BE PASSED TOO. SUPPOSE A FUNCTION OF 2 ARGUMENTS IS CALLED: FNEW(X,Y). WHEN CONTROL GOES TO FNEW, TH VALUE OF X IS IN THE FLAC AND THE CHAR REGISTER CONTAINS ",", WITH TEXT POINTERS POINTING TO THE COMMA AFTER THE X IN THE ARGUMENT LIST. (NOTE: R0 IS GENERALLY AVAILABLE IN USER ROUTINES, AS IS R5. MOST OTHER REGISTERS HAVE SPECIAL MEANINGS AND SHOULD BE SAVED AND RESTORED IF USED THERE. HOWEVER, THEY SHOULD BE ALLOWED TO BE MODIFIED BY FOCAL ROUTINES SUCH AS GETC AND SPNOR TO LET FOCAL KEEP TRACK OF WHERE IN THE TEXT ARGUMENTS ARE.) SET AA=FNEW( X , Y) ^ ^ FLAC CHAR WHEN FNEW WANTS TO EVALUATE Y, IT SHOULD CALL EVAL.X TO GET IT. FOR EXAMPLE: ;SAVE 2 ARGUMENTS ON STACK FPUT=7060 STACK=0 INTO=3 EVAL.X=104660 GETARG: CMP -(SP),-(SP) ;RESERVE 2 STACK CELLS FPUT+INTO+STACK ;SAVE X ON STACK EVAL.X ; GET Y CMP -(SP),-(SP) ;SAVE 2 MORE STACK CELLS FPUT+INTO+STACK . . . A VARIABLE NUMBER OF ARGUMENTS CAN BE HANDLED BY USING SORTC TO CHECK FOR CHAR CONTAINING 211 (INTERNAL CODE FOR ")") AND PUSHING OR OTHER PROCESSING OF ARGS UNTIL SEEING THE PARENTHESIS. THE FCHR FUNCTION IN FOCAL IS AN EXAMPLE OF THIS TECHNIQUE. E. FOCAL INTERNAL DATA FORMATS 1. TEXT DATA FOCAL TEXT IS STORED IN LINKED LINES AND EACH LINE IS STORED AS A STRING OF 7-BIT ASCII CHARACTERS, WITH ALL TERMINATORS CODED IN A SPECIAL INTERNAL FORM. THE LAST CHARACTER IS ALWAYS 216 (INTERNAL CODE FOR CR.) AND NO FURTHER CHARACTERS SHOULD BE USED BEYOND THE CR. ALL TEMINATORS HAVE NEGATIVE INTERNAL CODES SO A BMI AFTER A GETC LETS YOU PROCESS COMPLETION. EACH TEXT LINE HAS AN EXPLICIT LINE NUMBER COMPOSED OF A GROUP PLUS AN EXTENSION. THESE ARE 2 BYTES OF DATA. THE FIRST WORD OF THE LINE IS A 16-BIT POINTER TO THE NEXT LINE, TAKEN RELATIVE TO THE CURRENT LOCATION MINUS TWO (NEXT-.-2). THIS IS TO ALLOW EASY CHAINING FROM ONE ENTRY TO THE NEXT VIA AN INSTRUCTION LIKE "ADD (R0)+,R0" (!!). THE SECOND WORD IS THE 2-BYTE LINE NUMBER AND THEREAFTER IS THE TEXT. ALL INPUT COMES INTO A SPECIAL BUFFER PRIOR TO PACKING THIS WAY, AND IS PACKED IN THIS FORMAT. CONSIDER LINE 12.50, SAY. ITS FORMAT IS STORAGE IS: NEXT-.-2 .BYTE 50.,12. (TEXT BYTES) .BYTE 216 ;CR CODE MUST TERMINATE IT .EVEN ;ALSO ENDS ON A WORD BOUNDARY 2. VARIABLES FOR NORMAL FLOATING-POINT VARIABLES, FOCAL CREATES VARIABLES AS THEY ARE NEEDED AND STORES EACH WITH ITS OWN SUBSCRIPT. EACH VARIABLE HAS ITS OWN 8-BIT EXPONENT AND 24-BIT SIGNED MANTISSA, RESERVED IN STORAGE AS FOLLOWS: NAME (2 ASCII CHARACTERS)(INTERNAL FOCAL CODE) SUBSCRIPT (16-BITS OR 2 BYTES OF 8 BITS) .BYTE EXP .BYTE LO MANTISSA .WORD HI MANTISSA (SIGNED) THE NAME MAY BE 1 OR 2 CHARACTERS. IF IT IS 1 CHARACTER, THE HIGH ORDER BYTE IS LEFT BLANK SINCE THE FIRST CHARACTER OF THE NAME IS TH LOW-ORDER BYTE. (THE FOCAL INTERNAL CODE FOR BLANK IS 200). DOUBLE SUBSCRIPTS HAVE THE FIRST SUBSCRIPT IN THE LOW BYTE AND THE SECOND IN THE HIGH BYTE. AN UNSUBSCRIPTED VARIABLE HAS A ZERO SUBSCRIPT WORD. THESE VARIABLE MAY BE GARBAGE-COLLECTED AND WILL BE 0 WHEN FIRST ALLOCATED. IF FOCAL NEEDS THE ROOM, IT MAY ERASE ZERO VARIABLES SINCE IF IT REALLOCATES THEM, THEY WILL AGAIN BE ZERO. THEY NEED NOT BE IN ANY PARTICULAR ORDER IN MEMORY. THE FOCAL SUBROUTINE GETARG WILL LOCATE A VARIABLE AND RETURN ITS ADDRESS (POINTING AT THE FIRST OF THE 2 DATA WORDS) WITH THE REGISTER PTR (R2). IT IS CALLED VIA JSR PC,GETARG WITH AXOUT POINTING TO THE NAME OF THE VARIABLE. BECAUSE NORMAL FOCAL ARRAYS ARE SCATTERED AROUND, RSX FOCAL PROVIDES AN INTEGER DATA TYPE CONSISTING OF A VARIABLE NUMBER OF 16-BIT WORDS IN NAMED ARRAYS. THESE ARRAYS HAVE NAMES WHOSE FIRST CHARACTER IS A LETTER AND WHOSE SECOND CHARACTER IS ALWAYS PERCENT SIGN (%). BECAUSE THEY ARE VARIABLE SIZE, THEY MUST BE PREALLOCATED WITH THEIR SIZE, AND ARE NOT GARBAGE-COLLECTED DURING PROGRAM EXECUTION. AGAINS THIS, THEY REQUIRE ONLY 1 WORD PER ELEMENT AND ARE IN A FORMAT EASY TO USE FROM ASSEMBLY LANGUAGE. THE FORMAT IS AS FOLLOWS IN STROAGE: .ASCII /C/ ;CHARACTER FOR FIRST LETTER OF NAME .ASCII /%/ ;ALWAYS % FOR SECOND CHARACTER .WORD 0 ;SUBSCRIPT .WORD SIZE ;NUMBER OF DATA ENTRIES (STARTING FROM 0) .BLKW SIZE+1 ;BLOCK OF DATA (SET TO 0 WHEN ALLOCATED) INTEGER ARRAY ELEMENTS MAY BE USED IN NORMAL FOCAL ARITHMETIC (EXCEPT ASK) OR HANDLED BY USER ROUTINES AS DESIRED. IF THE SIGN BIT OF THE FIRST CHARACTER IS SET, THE VECTOR IS ASSUMED TO BE ADDRESSED AS A BYTE VECTOR. ALSO, SUBSCRIPT 0 OF A VECTOR WILL BE INITIALLY FILLED IN WITH THE ADDRESS OF ELEMENT 1 OF THE VECTOR, AND BYTE ADDRESSES START WITH THE HIGH ORDER BYTE OF THE NEXT WORD OF DATA. VARIABLES ARE PREALLOCATED WITH A STATEMENT OF FORM V R(45) TO ALLOCATE INTEGER ARRAY R% WITH MAXIMUM DIMENSION 45. THIS ARRAY WILL REMAIN IN CORE UNTIL ERASED AND MAY BE TREATED AS FIXED. IT WILL BE FILLED WITH ZEROES UPON ALLOCATION. NOTE THAT THE FORM ABOVE IS RELATIVELY INFLEXIBLE, I.E., NO EXTRA CHARACTERS MAY BE INSERTED. ANY LETTER (EXCEPT F) MAY BE USED. TOTAL SPACE FOR VECTORS MUST BE PRE-ALLOCATED WITH A COMMAND OF THE FORM "VECTOR 1000" (ALLOCATE 1000. WORDS FOR VECTORS) PRIOR TO DEFINING ANY VARIABLES. THE COMMAND 'VECTOR "V%' WILL CHANGE A VECTOR TO BYTE ADDRESSING; THE COMMAND 'VECTOR #V%' WILL CHANGE IT BACK TO WORD ADDRESSING. F. CORE ARRANGEMENT FOCAL'S CORE LAYOUT IS AS FOLLOWS ......END OF MEMORY..... VARIABLES . . .(MOVING BOUNDARY). . . TEXT ........................ FOCAL INTERPRETER ........................ COMMAND-INPUT BUFFER ........................ TABLES ........................ STACK 0....................... G. HOW TO ADD ANOTHER FUNCTION TO FOCAL ALL FOCAL FUNCTIONS HAVE NAMES BEGINNING WITH F. THE NAME MAY BE OTHERWISE WHATEVER YOU LIKE. PICK YOUR FUNCTION NAME AND MAKE UP A FOCAL HASH CODE AS FOLLOWS FOR THE NAME: 1. FIND THE 7 BIT ASCII VALUE FOR EACH LETTER IN THE MNEMONIC 2. MULTIPLY EACH OF THESE LETTERS BY ITS PLACE VALUE IN A BASE 5 SYSTEM; THAT IS, THE RIGHTMOST IS MULTIPLIED BY1, THE NEXT TO THE LEFT BY 4, THE NEXT TO THE LEFT BY 4^2M THE NEXT BY 4^3, AND SO ON. PERFORM ALL MATH IN OCTAL. IF THE RESULT IS GREATER THAN 177777 (OCTAL), BITS TO THE LEFT ARE LOST AND ZEROES COME IN FROM THE RIGHT. 3. ADD THE PRODUCTS TO FORM THE HASH CODE. EXAMPLE USING FSBR F=106 S=123 B=102 R=122 R=122 = 122 B=102 X4 = 410 S=123 X20 = 2460 F=106 X100 = 10600 SUM = 14012 NOW LOOK IN THE FOCAL FUNCTION TABLE AND MAKE SURE YOUR HASH CODE IS UNIQUE. IF NOT, PICK A NEW NAME. IF SO, PUT THE FUNCTION HASH CODE AND ADDRESS INTO THE TABLE IN FASHION SIMILAR TO THE FUNCTIONS THERE ALREADY. FOCAL SHOULD THEN BE ABLE TO USE IT. H. FOCAL ERROR MESSAGES 00 MANUAL RESTART 01 ILLEGAL LINE NUMBER 02 ILLEGAL VARIABLE OR FUNCTION NAME 03 PARENTHESIS MISMATCH 04 ILLEGAL COMMAND 05 NONEXISTENT LINE NUMBER 06 NON EXISTENT GROUP NUMBER IN DO 07 ILLEGAL FORMAT IN SET OR FOR 08 DOUBLE OR MISSING OPERATORS IN EXPRESSION 09 STACK OVERFLOW OR NONEXISTENT DEVICE 10 CORE FILLED BY TEXT OR COMMAND LINE TOO LONG 11 CORE FILLED BY VARIABLES OR NO ROOM FOR VARIABLES 12 EXPONENT TOO LARGE (ABSOLUTE VALUE GREATER THAN 38) 13 ILLEGAL BUS ADDRESS IN FX 14 DIVISION BY ZERO ATTEMPTED 15 ATTEMPT TO EXPONENTIATE A NEGATIVE POWER OR A POWER TOO LARGE 16 TOO MANY CHARACTERS IN INPUT DATA 17 SQUARE ROOT OF NEGATIVE NUMBER 18 INPUT BUFFER OVERFLOW 19 SYNTAX ERROR IN LIBRARY DATASET DEFINITION 20 ILLEGAL LIBRARY FUNCTION 21 UNABLE TO OPEN LIBRARY FILE 22 LOG OF NEGATIVE NUMBER 23 FAND SYNTAX ERROR 24 FINT SYNTAX ERROR OR ATTEMPT TO BASH EMT VECTOR 25 FADR SUBSCRIPT TOO LARGE 26 FRCHR CODE OF 0 28 ADDRESS ERROR IN FMHST OR FHIST 29 INIT ERROR IN USING 30 OPEN OR SYNTAX ERROR IN USING 31 ILLEGAL DATA ADDRESS IN USING 32 FLIM ADDR ERROR 35 FLIMT OR FWRD ADDR ERROR J. CUSTOM-TAILORING FEATURES FOCAL HAS SEVERAL CONDITIONAL ASSEMBLY PARAMETERS TO DELETE SOME OF THE EXTRA FUNCTIONS. THEY ARE: XHIST DEFINED,DELETES FHIST AND FMHST XMOV DEFINED,DELETES FMOV, FBYT, FASR, AND FASL XRTKB DEFINED, DELETES FRCHR XUSING DEFINED, DELETES ALL "USING" COMMANDS IN ADDITION, THE LOCATION "ASKZER", A GLOBAL, CONTAINS THE CHARACTER PUT IN FRONT OF ALL "ASK" INPUT PRIOR TO EVALUATION. IT IS NORMALLY 60 (ASCII 0) TO FORCE ALL INPUT TO BE EVALUATED AS NUMERIC. HOWEVER, IF SET TO 200 (INTERNAL FOR SPACE), ASK CAN INPUT EXPRESSIONS OR VARIABLES TO BE EVALUATED BY FOCAL. THE ONLY DIFFICULTY WITH THIS IS THAT A REPLY OF "YES" MUST THEN BE ENTERED AS "0YES" FOR THE USUAL "IF" COMPARISON TO WORK. IT MAY BE EDITED AT SOURCE LEVEL OR PATCHED WITH A LINK GLOBAL PATCH OF FORM GBLPAT=FOCAL:ASKZER:200 TO MAKE A VERSION OF FOCAL ABLE TO INPUT EXPRESSIONS. (USERS OF DOS V08 CAN ACHIEVE THIS RESULT USING A LINK-MAP AND THE GET MODIFY AND SAVE COMMANDS TO MAKE A PATCHED VERSION.) IN ADDITION, IF THE CONDITIONAL "EXSYM" IS DEFINED, FOCAL WILL ASSEMBLE INTO A VERSION THAT WILL TREAT VARIABLES AS THEY ARE TREATED IN BASIC; THAT IS, A, A(0), AND A(0,0) WILL ALL BE SEPARATE VARIABLES, NOT THE SAME AS IS THE USUAL STANDARD. THIS IS DONE BY SETTING THE HIGH BIT OF THE BYTES OF EACH CHARACTER OF THE NAME TO DISTINGUISH SUBSCRIPTED AND UNSUBSCRIPTED VARIABLES. IF "ONEINT" IS DEFINED, FOCAL WILL ONLY HANDLE ONE INTERRUPT VECTOR AND FINT'S PRIORITY ARGUMENT SHOULD BE OMITTED. THIS IS SOMEWHAT SHORTER THAN THE STANDARD VERSION, AND MAY BE PERMITTED IF DESIRED.