/TMATH.PA / MODIFICATIONS BY: / / 047 KMD 23-Sep-85 Dutch Xlations / 046 KMD 10-Sep-85 Change keywords for Spanish / 045 KMD 02-AUG-85 Allow multinational control words / 044 RCME 24-Jun-85 Allow multinational currency symbols / / ------------------------ All below refer to V2.0 and earlier ---------------- / / 043 WCE 17-AUG-83 CHANGED NUMBER LABEL TO NUMTOK FOR PREFIX / 042 WCE 19-JUL-83 CHANGED SET LABEL TO SETCMD FOR PREFIX / 041 WCE 01-JUN-83 EXPAND SYMBOL TABLE BY REMOVING MTHTBL / 040 WCE 28-APR-83 FIX BUG - KEEP ONLY ONE COPY OF NUMBER / IN SYMBOL TABLE LIST / 039 WCE 24-APR-83 FIX BUG - ALLOW SET TO CHANGE FORMAT / 038 DRH 09-FEB-82 FIX BUG - RESET COUNTER IN COM PARSER / 037 DRH 27-JAN-82 FIX BUG - CATCH TRAPPED ERR "END" NOT / ON SECOND LINE / 036 DRH 27-JAN-82 FIX BUG - TRAP ERR ON LINES AFTER "END" / REF. WPEDIT.PA EDIT HISTORY "134" / 035 DRH 26-JAN-82 FIX BUG - 2ND LINE OF NON EDITOR MATH / BLK BLOWS LINE AFTER BLOCK OUT OF H2O / FIX BUG - INVALID PROCESSING OF "END" / IN EDITOR MATH CTRL BLOCK / 034 DRH 18-DEC-81 STRIP OUT BACK-UP RELATED CODE / 033 DRH 01-DEC-81 REINSTALLED "BEGIN" CTRL WORD PROCESS- / ING IN "BEGIN" RTN. REF EDIT HISTORY / NUMBER 025 / 032 DRH 01-DEC-81 FIXED BUG IN FORMULA TRANSLATOR / 031 DRH 18-NOV-81 CHANGED "RUNCHK" FLAG SETTING / 030 DRH 16-NOV-81 ADD SYM TO "DCHAR" IF MATCH IN TABLE / 029 JRF 16-NOV-81 Modified calls to ZROTBL since it was / made cross field callable. / 028 JRF 9-NOV-81 Add code for zeroing of DCHAR table / upon detectiion of WPSMATH in cntrl. / block. / 027 DAO 6-NOV-81 ADDED CODE TO BEGIN AND END ROUTINES / TO SET FLAGS FOR 'BACKUP' CODE / 026 JRF 4-NOV-81 Add error calls for cntl. word format / and syntax errors. / 025 JRF 02-NOV-81 Temporarily commented out "BEGIN" / processing code in "BEGIN" routine. / Must be reinstalled later as soon as / Editor Math Error Reporting is / operational!! (SEE /T025). See Joe / or Dave if you have any questions. / 024 DRH 30-OCT-81 ADDED EDIT MATH ERROR LABELS & / CALLS TO CHECK FOR CHAR ON LINE / AFTER "BEGIN" & "END" CTRL WORDS / 023 DAO 28-OCT-81 MINOR CHANGE TO CALL TO CHKNME / 022 DRH 23-OCT-81 RE-INIT RESULT TBL & PTR AT START OF / EVERY EDITOR MATH BLOCK / 021 DRH 16-OCT-81 ADDED EDITOR MATH ERROR HANDLING CODE / 020 DRH 23-SEP-81 ADDED INDIVIDUAL EDITOR MATH CTRL WORD / HANDLING ROUTINES / 019 DRH 14-SEP-81 ADDED EDIT MATH CTRL WORD PROCESSING / 018 DRH 14-SEP-81 ADDED EDIT MATH CONTROL WORDS "BEGIN, / END, & TOTAL" TO MATH MODULE / 017 DRH 14-SEP-81 ADDED CODE TO INDICATE WHETHER IN LP / OR EDITOR MATH / 016 DRH 02-SEPT-81 TRAP ILLEGAL HARD RETURN WITHIN A / FORMULA OR SET STATEMENT MATH EXPRSION / 015 DRH 18-AUG-81 SET "EVFLW7" COMPATIBLE TO ERR REPORTING / 014 DRH 11-AUG-81 SET UP "LNEBFC" IN "RDLNBF" TO RETURN / CONTENTS OF FULL INPUT LINE BUF WHEN / BUF OVERFLOWED IN MATH CTRL BLOCK / 013 DRH 08-AUG-81 SEND BACK EXACT LOC OF NON-ALLOWABLE / CHAR ON CTRL WRD LNE AFTER CTRL WORD / SET UP TO BE COMPATIBLE WITH "RDLNBF" / 012 DRH 31-JUL-81 SET CODE TO NOT RE-INIT SYMBOL TBL, / SYMBOL PTR TBL, & RESULT PTR TBL / BETWEEN CTRL BLKS OF SAME LP LIST DOC / 011 DRH 28-JUL-81 TRAP OUT CTRL WORD FORMAT/SYNTAX ERRS / 010 DRH 27-JUL-81 HANDLE MATH INPUT LINE BUFFER & WORK / BUFFER OVERFLOW ERRORS - TIED IN WITH / "WPSELC" MODULE EDIT NUMBER - "024" / 009 DAO/DRH 23-JUL-81 CHECK FOR MULTIPLE FORMAT STATEMENTS / FOR SAME RESULT VAR. IN ONE CTRL BLK / 008 DRH 17-JUL-81 ADDED CODE TO TRAP INCORRECT FORMULA / FORMAT FOLLOWED BY END OF LINE (HR) / 007 DAO 15-JUL-81 /Changes to fix bug in where format / /indicator got loaded / 006 DAO 14-JUL-81 /Played space wars on first page (some- / /body installed with page errors!!! / 005 DAO 12-JUL-81 /Changed SYMTSZ and so it now outputs / / char passed in AC. Also changed so / / address following PUSH points to / / actual value rather than format word / 004 DRH 10-JUL-81 /PLACE "INIT" INTO OUTPUT LIST FOR USE / /BY FORMULA EXECUTION CODE / 003 DAO 7-JUL-81 / CHANGE SYMCHK TO RETURN POINTER INTO / / SYMBOL TABLE / 002 DAO 14-JUN-81 / MODIFICATIONS TO MERGE WITH OTHER / / MATH FILES / 001 DRH 5/6/81 /ADDED CODE FOR "RESULTS POINTER LIST" / 000 DRH 30-APR-81 /CREATED /PCBMTH.PA /D002 /THIS PART OF CODE HANDLES INTERACTION WITH LIST PROCESSING/EDITOR REGARDING /THE PARSING OF THE PRINT CONTROL BLOCK. /START WITH INITIALIZATION PROCESS WHEN FIRST ENTER PRINT /CONTROL BLOCK /WARNING: IMPORTANT TO KEEP "FSTLNE", & "RTRN1 TO 4" IN PRESENT LOCATIONS / SINCE THEY ARE DEFINED AS SUCH IN WPF1 FOR L.P. AND THE EDITOR / AS ENTRY POINTS TO THE MATH MODULE. FSTLNE, 0 /"CONTROL BLOCK FIRST LINE" FLAG RTRN1, XX /ENTRY POINT TO RTN TO INITIALIZE INPUT LINE BUF PTR JMP RTRN1A /GO TO CODE WHICH INITIALIZES THE PTR RTRN2, XX /ENTRY POINT TO RTN TO PUT CHAR IN INPUT LINE BUF JMP RTRN2A /GO TO CODE WHICH INPUTS CHAR RTRN3, XX /ENTRY POINT TO RTN TO PROCESS INPUT LINE IN BUF JMP RTRN3A /GO PROCESS INPUT CHAR STRING IN LINE BUFFER RTRN4, XX /RTN TO INITIALIZE VALUES USED IN MATH CTRL BLK CODE DCA MTHTYP /GET VALUE PASSED IN AC FROM CALLER FIELD AND /A017 /USE IT TO SET THE "MTHTYP" FLAG TO INDICATE /A017 /WHICH TYPE OF MATH IS GOING TO BE INVOKED /A017 /IF LP MATH THEN "MTHTYP" = 0, IF EDIT MATH = 1 /A017 /NOTE - THIS FLAG SETTING PROCESS IS DONE /A017 /ONCE WHEN ENTERING THE PARTICULAR MODULE WHICH /A017 /REQUIRES MATH FUNCTIONALITY AND AGAIN EACH TIME/A020 /MATH IS RE-INITIALIZED AT THE START OF A MATH /A020 /WORK AREA FROM THE "BEGIN" ROUTINE /A020 /************ BE WARNED THAT *************** /A017 /A CROSS FIELD CALL IS MADE TO "RTRN4" FROM /A017 /THE MODULE (EDIT OR LP) USING MATH THEREFORE /A017 /IF "MTHTYP" IS MOVED OFF OF PAGE ZERO THEN /A017 /THERE WILL BE THE PROBLEM OF HAVING TO INDIRECT/A017 /TO THAT LOC FROM HERE, THUS USING THE DATA /A017 /FIELD FROM THE CALLING MODULE WHICH WILL RESULT/A017 /IN AN ERROR /A017 JMP RTRN4A /GO INITIALIZE VALUES /ROUTINE TO INITIALIZE INPUT LINE BUFFER POINTER RTRN1A, GOTFLD /GET CDI INTRUCTION /M041 DCA BCKFLD /SAVE THE CONSTRUCTED CDI INSTRUCTION FOR RETURN TAD (LNEBUF /GET START OF INPUT LINE BUFFER DCA LNEPTR /USE IT TO INITIALIZE THE INPUT LINE BUFFER PTR DCA FRMCHR /INIT VAL IN LEXIC RTN BEFORE ENTRY LATER BY XLTFRM BCKFLD, 0 /LOCATION TO HOLD CDI INSTRUCTION FOR RETURN TO CALLER JMP I RTRN1 /RETURN PROGRAM CONTROL TO FIELD FROM WHICH CALL MADE /ROUTINE TO PUT INPUT CHAR INTO INPUT LINE BUFFER. RTRN2A, /D006 RDF /GET THE DATA FIELD BITS FROM WHICH THE CALL WAS MADE TAD CIDF0 /ADD TO IT THE CDF,CIF OCTAL CODE VALUE DCA OLDFLD /SAVE THE CONSTRUCTED CDI INSTRUCTION FOR RETURN TAD I RTRN2 /GET INPUT CHAR PASSED FROM OTHER FIELD CDFMTH /CHANGE THE DATA FIELD REGISTER TO MATH FIELD DCA I LNEPTR /SAVE IT IN THE INPUT LINE BUFFER /IN CASE IN EDITOR MATH, BEFORE GOING BACK FOR NEXT CHAR, CHECK /A021 /TO SEE IF LAST VALID LINE PROCESSED IN THE EDITOR MATH CONTROL /A021 /BLOCK WAS AN "END" CONTROL WORD. IF SO THEN THERE SHOULD BE NO /A021 /OTHER LINES TO PROCESS IN THE CONTROL BLOCK. IF THERE ARE LINES/A021 /AFTER THE "END" CTRL WORD THEN THE LINE IS SPOTTED AS AN ERROR /A021 TAD MTHSND /GET EDITOR MATH "SECOND LINE" FLAG /A021 SMA CLA /HAS "END" CTRL WORD BEEN PREVIOUSLY FOUND? /A021 JMP SKPDN1 / NO: THEN CONTINUE PROCESSING /A021 TAD (EVSYN6 / YES: RETURN ERR - LINES AFTER "END" WORD/A021/M024 JMP ERROR6 /SETUP TO RETURN NUMBER TO EDITOR MATH /A021 SKPDN1, JMS LNETSZ /INCREMENT LINE BUFFER PTR & CHECK FOR OVERFLOW /M021 /NOTE: RETURN FROM "LNETSZ" WITHOUT A SKIP TO CONTINUE LOADING IN CHAR / TO INPUT LINE BUFFER: WITH A SKIP RETURN IF THERE WAS AN INPUT / LINE BUFFER OVERFLOW AND IT IS NOT A MATH CONTROL BLOCK: & A / DOUBLE SKIP RETURN IF A MATH CTLR BLK LINE BUF OVFLW ERROR /A010 ISZ RTRN2 /TRIPLE INCREMENT PC FOR NORMAL RETURN TO OTHER FIELD ISZ RTRN2 /DOUBLE INCREMENT PC & RTRN TO SERVE NOT MATH BLOCK ERROR6, ISZ RTRN2 /SINGLE INCRMNT PC TO RTRN MATH CTRL BLK ERR /M021 OLDFLD, 0 /LOCATION TO HOLD CDI INSTRUCTION FOR RETURN TO CALLER JMP I RTRN2 /RETURN PROGRAM CONTROL TO FIELD FROM WHICH CALL MADE / "RTRN3" - ROUTINE TO PROCESS INPUT CHAR STRING IN LINEBUFFER / /FUNTIONAL DESCRIPTION: RTRN3 /PSEUDO-CODE DESCRIPTION: / / | SAVE DATA FIELD TO RETURN TO CALLER / | PLACE LINEBUFFER CTRL WORD INTO WORK BUFFER / | IF WORK BUFFER OVERFLOW / | | THEN IF CONTROL BLOCK FIRST LINE = TRUE / | | | THEN RETURN TO CALLER AS NOT MATH BLOCK / | | | ELSE RETURN TO CALLER WITH MATH WORK BUFF ERROR / | | | ENDIF / | | ENDIF / | IF CTRL BLOCK FIRST LINE FLAG = TRUE / | | THEN COMPARE LINEBUFFER CTRL WORD TO WPSMTH TABLE / | | IF MATCH FOUND / | | | THEN SET CTRL BLOCK FIRST LINE = FALSE / | | | IF NON-ALLOW CHAR ON SAME LNE AS & AFTER CTRL WRD / | | | | THEN RETURN TO CALLER WITH MATH ERR IN AC / | | | | ENDIF / | | | INITIALIZE TRUNCATE/ROUND FLAG = ROUND / | | | " FORMULA CTRL WORD NOT FOUND = TRUE / | | | " FRMLA EXEC CDE ENTRY PT=START O/P LST / | | | " LEAD LOC OF O/P LST = SUBRTN SETUP / | | | " O/P LIST POINTER / | | | IF IN EDITOR MATH = TRUE / | | | | THEN INITIALIZE RESULT PTR TABLE & PTR / | | | | ENDIF / | | | INITIALIZE EDIT MATH "SECOND LINE" FLAG = TRUE / | | | ELSE RETURN TO CALLER TO PROCESS AS NOT MATH BLOCK / | | | ENDIF / | | RETURN TO CALLER TO CONTINUE NORMAL PROCESSING OF MTH BLK / | | ELSE COMPARE CTRL WORD TO "CTLWRD" OR "EDTCTL" TABLE / | | IF MATCH FOUND / | | | THEN PROCESS ACCORDING TO CTRL WORD FOUND / | | | IF ERROR FOUND WHILE PROCESSING / | | | | THEN RETURN TO CALLER WITH MATH ERR IN AC / | | | | ENDIF / | | | ELSE RETURN TO CALLER WITH FORMAT/SYNTAX ERR IN AC / | | | ENDIF / | | ENDIF / /CALLING SEQUENCE: CIFMTH /CROSS FIELD CALLABLE..... / JMS RTRN3 /......SUBROUTINE - WHERE RTRN3 IS A / /......SPECIFIC ENTRY POINT INTO MATH / /......AS DEFINED IN WPF1. /INPUT PARAMETERS: NONE /IMPLICIT INPUT: LNEBUF,FSTLNE /OUTPUT PARAMETERS: NORMAL RETURN = CONTINUE PROCESSING / SKIP RETURN = WITH MATH BLOCK ERROR IN THE AC / DOUBLE SKIP RETURN = ERROR BUT NOT MATH BLOCK /IMPLICIT OUTPUT: MATH INITIALIZATION,FSTLNE /COMPLETION CODE: NONE /SIDE EFFECTS: NONE /ROUTINE TO PROCESS CONTROL WORD OF INPUTTED LINE RTRN3A, GOTFLD /GET CDI TO CALLING FIELD /M041 DCA RTNFLD /SAVE THE CONSTRUCTED CDI INSTRUCTION FOR RETURN JMS XCTRLW /GO SET UP CONTROL WORD FOR COMPARISON WITH SYM TBL /THE "XCTRLW" RTN PERFORMS A VARIETY OF GYMNASTICS BEFORE /A010 /RETURNING. IN THE CASE OF A WORK BUFFER OVERFLOW A CHECK /A010 /IS DONE TO SEE WHAT LINE OF THE CONTROL BLOCK IS BEING /A010 /PROCESSED. IF A WORK BUFFER OVERFLOW OCCURS WITH THE FIRST /A010 /LINE THEN THE BLOCK IS NOT MATH BECAUSE IF IT WERE THERE /A010 /WOULD BE NO OVERFLOW. IF IT IS NOT THE FIRST LINE THEN /A010 /THE BLOCK HAS TO BE MATH TO HAVE GOTTEN BEYOND THE FIRST LINE /A010 /THE CASES SPECIFIED ARE HANDLED VIA SKIP RETURNS FROM "XCTRLW" /A010 JMP KPPROC /RETURN HERE TO CONTINUE NORMAL PROCESSING /A010 JMP ERBCK1 /RETURN HERE TO PROCESS AS NOT MATH CTRL BLOCK /A010 JMP ERRBCK /RETURN HERE TO PROCESS MATH WORK BUFFER ERROR /A010 /....ERROR NUMBER IN AC WHEN RTRN FROM "XCTRLW" /A010 /....SET UP TO RETURN TO FIELD ACCORDINGLY /A010 /CHK IF 1ST LINE OF CONTROL BLOCK KPPROC, TAD FSTLNE /GET CONTROL BLOCK 1ST LINE FLAG /M010 SNA CLA /IS IT THE FIRST LINE OF THE CONTROL BLOCK? JMP PRFRST / YES: GO SEE IF IT'S "WPSMATH" JMP PRCTRL / NO: HANDLE ANY OF OTHER CONTROL WORDS /HANDLE FIRST LINE OF CONTROL BLOCK - SEE IF IT IS "WPSMATH" PRFRST, JMS CMDPSR /RUN COMMAND PARSER ON CONTROL WORD WRKBUF /PASS START OF INPUT STRING TO COMMAND PARSER WPSMTH /PASS START OF SYMBOL TABLE TO COMMAND PARSER SZA /IS RETURNED VALUE IN THE AC A 1? i.e. A MATCH FOUND? JMP PRFRT1 / YES: GO INITIALIZE VALUES TO PROCESS MATH CTRL BLK ERBCK1, ISZ RTRN3 / NO: SET PC FOR DOUBLE SKIP RETURN TO PROCESS /M010 ISZ RTRN3 /....NOT MATH BLOC JMP RTNFLD /AND RETURN TO CALL FIELD PRFRT1, DCA FSTLNE /SET "CONTROL BLOCK FIRST LINE" FLAG = FALSE JMS CHKLNE /CHK FOR NON-ALLOWABLE CHARS ON SAME LINE AS AND..... /....AFTER CONTROL WORD JMP ERRBCK /RETURN HERE FROM "CHKLNE" WITH ERROR NUM IN AC /A011 /.. TO PASS BACK IF NON-LEGAL CHARS FOUND ON LNE/A011 /RETURN HERE FROM "CHKLNE" IF ALL WENT WELL /M012 /AT THIS POINT DECIDED TO SAVE THE SYMBOL TABLE, SYM PTR TBL, /A012 /AND RESULT PTR TBL CONTENTS FROM ONE MATH CONTROL BLOCK TO THE /A012 /NEXT WITHIN THE SAME LP LIST DOC. IN THIS WAY THE USER CAN STILL/A012 /GET VALID TOTALS IN THE TRAILER FROM ACROSS THE WHOLE LIST, NOT /A012 /JUST THE PART COVERED BY THE LAST BLOCK, IF THE ABOVE MATH DATA /A012 /STRUCTURES WERE RE-INIT BEFORE EACH BLOCK THEN ANY PREVIOUS /A012 /CALCULATIONS DONE WITHIN THE LIST WOULD BE LOST. /A012 JMS ITLZO3 /..CALL MATH BLOCK INITIALIZATION ROUTINES /M012 /INIT TRUNCATE FLAG,"FORMULA CTRL WORD NOT FOUND"/A012 /FORMULA EXECUTION CODE ENTRY PT - "OUTENT", /A012 /OUTPUT LIST /A012 /D041 JMS ITLZO4 /AND OUTPUT LIST PTR /A012 /CONDITIONALIZE CODE TO RE-INITIALIZE RESULT TABLE & PTR AT THE /A022 /START OF EVERY MATH BLOCK IF IN EDITOR MATH. DONE THIS WAY TO /A022 /ALLOW MORE ROOM FOR RESULTS WITHIN THE CONTEXT OF ANY EDITOR /A022 /MATH WORK AREA. ALSO, NOTE THAT THIS CAN BE DONE THIS WAY IF IN /A022 /EDITOR MATH BECAUSE (UNLIKE THE L.P. MATH WHICH USES THE RESULTS/A022 /TABLE FOR POSSIBLE TRAILER TOTALS), THE EDITOR USES THE "TCHAR" /A022 /TABLE WHEN REFERENCING RESULTS VALUES FOR TOTALS AND THEREFORE /A022 /DOES NOT NEED RETENSION OF RESULTS BETWEEN BLOCKS. FOR MORE INFO/A022 /SEE ABOVE COMMENTS FOR "JMS ITLZO3". /A022 TAD MTHTYP /GET THE "MATH TYPE" FLAG /A022 SNA CLA /ARE WE IN EDITOR MATH? /M028 JMP PRFRT2 / NO: DON'T INIT. FOLLOWING TABLES /A028 /D041 JMS ITLZOL / YES: GO INITIALIZE THE RESULT TABLE & PTR /A022 TAD (RESULT /GET STARTING ADDRESS OF RESULT PTR TABLE /A041 DCA RESPTR /INITIALIZE PTR TO RESULT PTR TABLE /A041 DCA I RESPTR /INIT 1ST LOC OF RESULT PTR TABLE TO ZERO /A041 / AC0001 / ZERO DCHAR TABLE INCASE THIS WPSMATH CNTRL. /A028 / BLOCK IS TOTAL BLOCK. IF NOT A TOTAL BLOCK /A028 / BOTH DCHAR AND TCHAR TABLES WILL BE ZEROED /A028 / LATER. /A028 CIFLP / *** CAUTION *** - DF MUST EQUAL THIS FLD /M029 JMS ZROTBL /A028 / /NOTE THE EDIT MATH CTRL BLOCK "SECOND LINE" FLAG IS HERE INIT. /A020 /TO TRUE ONCE THE FIRST LINE OF THE BLOCK HAS BEEN PROCESSED /A020 /SUCCESSFULLY. THIS FLAG WILL BE NEEDED IF IN EDITOR MATH AND /A020 /IGNORED IF NOT. /A020 PRFRT2, DCA MTHSND / SET EDIT MATH "SECOND LINE" FLAG = TRUE /M028 JMP RTNFLD /GO BACK TO CALL FIELD TO PROCESS NEXT LINE OF BLOCK /RTN TO HANDLE ALL LINES (EXCEPT 1ST) OF MATH CONTROL BLOCK PRCTRL, JMS CMDPSR /CHECK CONTROL WORD FOR COMPARISON WRKBUF /PASS START OF INPUT STRING TO COMMAND PARSER SYMSTR, 0 /PASS START OF SYMBOL TABLE TO COMMAND PARSER /M019 /NOTE - THIS LOCATION IS PATCHED WITH THE RIGHT /A019 /ENTRY POINT INTO THE CTRL WORD PERMENANT SYMBOL/A019 /TABLE. THE PATCH IS MADE BY A CALL TO "SETCTL" /A019 /FROM THE INT ROUTINE "RTRN4" /A019 /THE ENTRY IS MADE AT "EDTCTL" IF EDITOR MATH /A019 /AND "CTLWRD" IF LP MATH /A019 SNA /IS RETURNED VALUE IN AC > 0 ? (i.e. IS MATCH FOUND?) JMP BCKERR / NO: PROCESS CONTROL BLOCK FORMAT/SYNTAX ERROR TAD OFFSET / YES: ADD OFFSET TO VALUE RETURNED IN THE AC /A019 /NOTE - "OFFSET" IS A VALUE PATCHED AT INIT TIME/A019 /THE SAME AS "SYMSTR" ABOVE. THE OFFSET IS USED /A019 /TO PAD THE RETURNED VALUE IN THE AC FROM /A019 /"CMDPSR" IF THE ENTRY POINT TO THE SYMBOL TABLE/A019 /STARTS AT "CTLWRD" FOR LP MATH /A019 /OTHERWISE THE RETURNED VALUE WILL NOT ADD UP /A019 /WITH "HNDCTL" TO GIVE THE RIGHT ROUTINE TO /A019 /SERVICE THAT CONTROL WORD /A019 /"OFFSET" = 3 IF LP MATH & 0 IF EDITOR MATH /A019 /TAKE TIME HERE TO CHECK TO SEE IF CONTROL WORD IS NOT "BEGIN" /A020 /IF NOT THEN GO SEE IF EDITOR MATH, IF YES THEN PROCESS EDITOR /A020 /MATH RELATED INFORMATION, IF NOT THEN JUST RETURN /A020 DCA TMPCTR /SAVE VALUE IN AC /A020 AC7777 /GET A -1 INTO THE AC /A020 TAD TMPCTR /ADD BACK VALUE TO IT /A020 SZA CLA /DOES NUM = 1? (I.E. IS THE CTRL WORD = "BEGIN")/A020 JMS RUNCHK / NO: THEN GO CHECK EDITOR MATH INFO /A020 TAD TMPCTR / YES: GET VALUE BACK INTO AC TO CONTINUE PROC /A020 /SET UP TABLE ADDR TO INDIRECT THRU TO PROCESS CTRL WORD /A020 TAD (HNDCTL-1 /ADD START OF TBL-1 TO RTRNED VALUE + OFFSET DCA HLDVAL /SAVE IT AS ADDR TO CONTROL WORD PROCESS TABLE ROUTINE TAD I HLDVAL /GET THE ROUTINE LOCATION CONTAINED IN OFFSET LOCATION DCA HLDVAL /SAVE IT TO INDIRECT THRU JMS I HLDVAL /GO PROCESS ACCORDING TO CONTROL WORD FOUND ERRBCK, ISZ RTRN3 /RETURN HERE FROM PROCESSING CTRL WORD IF THERE /M010 /....IS AN ERROR DETECTED IN THE MATH BLOCK RTNFLD, 0 /SKIP RETURN HERE FROM "JMS I HLDVAL" IF ALL /WENT OK. ( LOCATION OF CDI INSTRUCTION TO RETURN TO /CALLER FIELD ). JMP I RTRN3 /RETURN PROGRAM CONTROL TO FIELD FROM WHCH CALL MADE BCKERR, TAD (EVFLW7 /GET MATH BLK CTRL WORD FROMAT/SYNTAX ERROR NUM /M015 JMP ERRBCK /RETURN TO CALL FIELD WITH ERROR NUM IN AC /A011 OFFSET, 0 /CONTAINS OFFSET TO PERM SYM TBL FOR EDIT/LP MATH/A019 HLDVAL, 0 /KEEP ON SAME PAGE AS "PRCTRL" RTN, HOLDS INDIRECT /THRU WHICH CONTROL WORD PROCESS RTN IS CALLED /MOVED "FRMULA" RTN OFF THIS PAGE BECAUSE OF SPACE WARS. /M037 /INITIALIZATION SUBRTN CALLED FROM WPSELC.PA VIA "RTRN4" IN LOC 207. USED TO /PERFORM PRIMARY INIT OF MATH MODULE VALUES WHEN LP IS INVOKED. RTRN4A, GOTFLD /GET CDI TO CALLING FIELD /M041 DCA BAKFLD /SAVE THE CONSTRUCTED CDI INSTRUCTION FOR THE RETURN /D041 JMS ITLZOL /INIT RESULT PTR TABLE PTR & TABLE /M012 TAD (RESULT /GET STARTING ADDRESS OF RESULT PTR TABLE /A041 DCA RESPTR /INITIALIZE PTR TO RESULT PTR TABLE /A041 DCA I RESPTR /INIT 1ST LOC OF RESULT PTR TABLE TO ZERO /A041 /D041 JMS ITLZO2 /INIT SYMBOL PTR TBL PTR, SYMBOL TABLE PTR /M012 TAD (SYMTBL /GET STARTING ADDRESS OF SYMBOL TABLE /A041 DCA SYMPTR /INITIALIZE PTR TO SYMBOL TABLE /A041 JMS ITLZO3 /INIT TRUNCATE/FLAG, "FORMULA CTRL WORD NOT /A012 /FOUND" FLAG, FORMULA/EXECUTION CODE ENTRY /A012 /POINT - "OUTENT", OUTPUT LIST /A012 /D041 JMS ITLZO4 /INIT OUTPUT LIST PTR /A012 JMS SETCTL /GO INIT PATCHES TO "SYMSTR" AND "OFFSET" /A019 /TO COINCIDE WITH TYPE OF MATH TO BE USED /A019 /SEE "PRCTRL" RTN FOR EXPLANATION /A019 /ALSO, IF EDITOR MATH, THEN INIT "INCTLB" IN /A019 /LP FIELD TO 1 (I.E. IN CONTROL BLOCK = FALSE) /A019 BAKFLD, 0 /LOCATION OF CDI INSTRUCTION TO RETURN TO CALLER FIELD JMP I RTRN4 /RETURN TO FIELD CALLED FROM /TOTAL, MOVED HERE ON EDIT 041 TO MAKE SPACE /ROUTINE TO HANDLE "TOTAL" CONTROL WORD IN EDITOR MATH CONTROL BLOCK /A020 TOTAL, XX JMS CHKLNE /CHK FOR NON-ALLOWABLE CHARS ON SAME LINE AS... /A024 /....AND RIGHT AFTER CONTROL WORD /A024 JMP ERRBCK /RETURN HERE FROM "CHKLNE" WITH ERROR NUM IN AC /A026 /.. TO PASS BACK IF NON-LEGAL CHARS FOUND ON LNE/A026 AC0001 /A020 DCA MTHTOT /SET "EDIT MATH TOTAL" FLAG = TRUE /A020 AC0001 /GET 1 INTO THE AC /A037 DCA MTHSND /SET "NOT PROCESSING SECOND LINE" = TRUE /A037 ISZ TOTAL /SET UP SKIP FOR NORMAL RETURN /A020 JMP I TOTAL /A020 X=. / INDICATE FIRST FREE LOCATION /A041 / ------------------ PAGE /RTN TO CHECK FOR NON-ALLOWABLE CHARACTERS FOLLOWING THE CONTROL /WORD AND ON THE SAME LINE. USED WITH "WPSMATH", "TRUNCATE", AND /"ROUND" TO DUMP TRAILING "SPECIAL" CHARACTERS AND TRAP AS AN /ERROR ANY OTHERS. DOES A SKIP RETURN IF ALL WENT WELL AND A /A011 /REGULAR RETURN WITH THE ERROR NUM IN THE AC IF NOT. /A011 CHKLNE, XX /NOTE: FIRST CALL TO "RDLNBF" HAS TO BE TO BACK IT UP ONE CHAR /A013 /FROM WHERE IT LEFT OFF IN "XCTRLW" WHEN PUTTING THE FIRST /A013 /WORD OF THE CTRL WORD LINE INTO THE WORK BUFFER /A013 /OTHERWISE "LNEPTR" IN "RDLNBF" IS SET TO THE CHAR AFTER THE /A013 /CHAR FOLLOWING THE FIRST WORD ON THE LINE. /A013 AC7777 /SET AC TO -1 TO TELL "RDLNBF" TO BACK UP ONE /A013 /CHAR IN THE LINE BUFFER /A013 JMS RDLNBF /GO CALL "RDLNBF" TO SET UP FOR CHAR RIGHT /A013 /AFTER CONTROL WORD ON THE LINE /A013 CHKLN1, JMS RDLNBF /GET ANY CHAR TRAILING CTRL WORD OF INPUT LINE /M013 TAD (-ECNWLN /GET NEGATIVE OF HARD RETURN SNA /IS NEXT CHAR FOLLOWING CONTROL WORD A HARD RETURN? JMP LINEOK / YES: END OF LINE SET UP TO RETURN TO CALLER /M011 TAD (ECNWLN-ECSPC/ NO: RESET AC AND GET NEGATIVE OF "SPACE" CHAR SPA SNA CLA /IS NEXT CHAR FOLLOWING CTRL WORD A "SPECIAL" CHAR?/m044 /d044 JMP LNOTOK / NO: THEN CONTROL WORD LINE SYNTAX ERROR JMP CHKLN1 / YES: DUMP IT & GO PICK UP NEXT CHAR ON LINE LNOTOK, TAD (EYNR10 /GET CONTROL WORD LINE SYNTAX ERROR INTO AC /m044 SKP /AND RETURN TO CALLER WITH IT IN AC /m044 LINEOK, ISZ CHKLNE /INCREMENT PC & RETURN CAUSE ALL WENT OK /A011 SAYBYE, JMP I CHKLNE /RETURN TO CALLER /A011 /RTN TO PLACE 1ST WORD OF INPUT LINE INTO WORK BUFFER WITH FIRST WORD OF INPUT /FORMATTED TO BE COMPATIBLE WITH COMMAND PARSER FOR SYMBOL TABLE COMPARISON. CTRLSZ, 0 /SIZE OF CONTROL WORD PUT IN WORK BUFFER, KEEP ON /SAME PAGE WITH "XCTRLW" ROUTINE WRKPTR, 0 /POINTER TO WORK BUFFER, KEEP ON SAME PAGE WITH /"XCTRLW" ROUTINE XCTRLW, XX / DCA CTRLSZ /SET WRKBUF WORD SIZE CHARACTER COUNTER = 0 TAD (WRKBUF+1 /INITIALIZE BUFFER PTR & SAVE FIRST LOCATION... DCA WRKPTR /...IN BUFFER FOR SIZE OF WORD AC0001 /SET AC TO 1 JMS RDLNBF /CALL READ LINE BUFFER RTN TO INITIALIZE FOR READ CYCLE1, JMS RDLNBF /READ A CHAR FROM LINE BUF AND GET IT BACK IN AC AND P177 /MASK OUT HIGH (MODE) BITS DON'T NEED FOR COMPARISON TAD (-ECSPC /ADD TO IT NEGATIVE OF "SPACE" CHAR SPA SNA /IS THE CHAR RETURNED A SPECIAL CHARACTER JMP ENDWRD / YES: GO PROCESS END OF CONTROL BLOCK WORD TAD (ECSPC / NO: RESET AC TO ORIGINAL CHAR READ IN DCA I WRKPTR /PUT CHAR IN WORK BUFFER ISZ CTRLSZ /INCREMENT WORD SIZE COUNT JMS WRKTSZ / " WORK BUFFER PTR & CHECK FOR OVERFLOW /RETURN FROM "WRKTSZ" WITH NORMAL RETURN IF PROCESSING WENT OKAY/A010 /WITH A SKIP RETURN IF IT IS A MATH CTRL BLK WRK BUF OVERFLOW /A010 /AND WITH A DOUBLE SKIP RTRN IF AN OVERFLOW BUT NOT MATH BLOCK /A010 CNTPRC, JMP CYCLE1 /NORMAL RETURN - GO CONTINUE PROCESSING /m044 ISZ XCTRLW /RETURN HERE FOR MATH CTRL BLK WRK BUF OVERFLOW /A010 ISZ XCTRLW /RETURN HERE FOR WRK BUF OVFLW & NOT MATH BLOCK /A010 JMP I XCTRLW /RETURN TO CALLER TO PROCESS ACCORDINGLY /A010 /d044 CNTPRC, JMP CYCLE1 /GO GET NEXT CHARACTER FROM LINE BUFFER /M010 ENDWRD, AC7777 /SET AC TO A MINUS ONE TAD WRKPTR /DECREMENT WORK BUFFER PTR BACK TO LAST CHAR INPUT DCA WRKPTR /AND SAVE IT AC4000 /PUT 4000 IN AC FOR COMPATIBILITY MATCH IN SYMBOL TBLE TAD I WRKPTR /GET LAST CHARACTER ENTERED INTO WORK BUFFER DCA I WRKPTR /SAVE IT BACK AS LAST CHAR IN INPUT CONTROL WORD TAD (WRKBUF /GET START OF WORK BUFFER DCA WRKPTR /INITIAL PTR TO THAT LOCATION TAD CTRLSZ /GET LENGTH OF WORD PLACED IN WORK BUFFER DCA I WRKPTR /SAVE IT AT THE START OF THE WORD IN WORK BUFFER JMP I XCTRLW /RETURN TO CALLER /ROUTINE PERFORMS THE FOLLOWING FUNCTIONS: INCREMENTS THE INPUT LINEBUF /A010 /PTR AND CHECKS FOR AN OVERFLOW. IF NONE THEN IT DOES A NORMAL RETURN /A010 /IF THERE IS ONE THEN A CHECK IS MADE TO SEE IF IT IS THE FIRST LINE OF /A010 /THE BLOCK. IF NOT THEN MUST BE MATH CTRL BLK INPUT LINBUF OVFLW ERROR /A010 /OTHERWISE WOULD NOT HAVE GOTTEN THAT FAR. IF IT IS THE FIRST LINE THEN /A010 /MUST PUT THE FIRST WORD OF THE OVERFLOWED INPUT LINE INTO THE WORK BUF /A010 /IF THE FIRST WORD OVERFLOWS THE WORK BUFFER THEN IT IS REGARDED AS NOT /A010 /BEING A MATH CONTROL BLOCK AND IS PROCESSED ACCORDINGLY. IF THE FIRST /A010 /WORD DOES FIT INTO THE WORK BUFFER THEN IT IS CHECKED BY THE COMMAND /A010 /PARSER TO SEE IF IT IS "WPSMATH". IF IT IS NOT THEN IT IS REGARDED AS /A010 /NOT BEING A MATH CONTROL BLOCK AND IS PROCESSED ACCORDINGLY. IF IT IS /A010 /"WPSMATH" THEN IT IS CONSIDERED A MATH INPUT LINEBUF OVERFLOW ERROR /A010 LNETSZ, XX /MATH CTRL BLK INPUT LINE BUF OVFLW CHECK RTN ISZ LNEPTR /INCREMENT LINE BUFFER POINTER TAD (-UPLNE /GET UPPER LIMIT OF INPUT LINE BUFFER TAD LNEPTR /GET LATEST ADDR AVAILABLE IN INPUT LINE BUFFER SPA CLA /IS THE INPUT LINE BUFFER OVERFLOWED? JMP I LNETSZ / NO: JUST RETURN TO CALLER TAD FSTLNE / YES: GET "CONTROL BLOCK FIRST LINE" FLAG SZA CLA /IS IT THE FIRST LINE OF THE CONTROL BLOCK? JMP YESMTH / NO: SERVICE MATH CTRL BLK LINBUF OVFLW ERROR /A010 /IF 1ST LINE OF CTRL BLK & IS OVERFLOW THEN SEE IF MATH CTRL BLK/A010 JMS XCTRLW /PUT 1ST WORD OF 1ST LINE OVERFLOW INTO WORK BUF/A010 /THE "XCTRLW" RTN PERFORMS A VARIETY OF GYMNASTICS BEFORE /A010 /RETURNING. IN THE CASE OF A WORK BUFFER OVERFLOW A CHECK /A010 /IS DONE TO SEE WHAT LINE OF THE CONTROL BLOCK IS BEING /A010 /PROCESSED. IF A WORK BUFFER OVERFLOW OCCURS WITH THE FIRST /A010 /LINE THEN THE BLOCK IS NOT MATH BECAUSE IF IT WERE THERE /A010 /WOULD BE NO OVERFLOW. IF IT IS NOT THE FIRST LINE THEN /A010 /THE BLOCK HAS TO BE MATH TO HAVE GOTTEN BEYOND THE FIRST LINE /A010 /THE CASES SPECIFIED ARE HANDLED VIA SKIP RETURNS FROM "XCTRLW" /A010 JMP MTHCHK /IF WORD PUT IN WRK BUF O.K. GO SEE IF MATH BLK /A010 JMP NOTMTH /IF OVERFLOW THEN NOT MATH, SET UP TO DUMP BLOCK/A010 /NOTE: NORMALLY "XCTRLW" WILL DO A DOUBLE SKIP /A010 /RETURN WHEN THE BLOCK IS MATH AND THE WORK BUF /A010 /IS OVERFLOWED. IN THIS CONTEXT, HOWEVER, IT CAN/A010 /NEVER DOUBLE SKIP RETURN BECAUSE THIS CODE IS /A010 /USED ONLY WHEN SERVICING A INPUT LINEBUF OVFLW /A010 /ON THE 1ST LINE OF THE BLOCK. THEREFORE IF THE /A010 /WORK BUF OVERFLOWS AT THIS POINT IT IS ASSUMED /A010 /TO NOT BE A MATH CONTROL BLOCK & IS PROCESSED /A010 /AS SUCH. MTHCHK, JMS CMDPSR /CHK IS 1ST WORD OF OVRFLOWED 1ST LINE "WPSMATH"/A010 WRKBUF / PASS START OF WORK BUFFER TO "CMDPSR" /A010 WPSMTH / PASS START OF PERMANENT SYM TBL FOR COMPARISON/A010 SNA CLA /IS RETURNED AC A 1 (I.E. MATCH FOUND)? /A010 JMP NOTMTH / NO: THEN PROCESS AS NOT MATH CTRL BLOCK /A010 YESMTH, /SINCE "RDLNBF" IS USED BE THE ERROR HANDLING CODE TO PLACE THE /A014 /INPUT LINE BUFFER ERROR UP ON THE SCREEN, IT MUST BE MADE /A014 /COMPATIBLE WITH THIS OVERFLOW ERROR ENCOUNTERED, BY SETTING THE/A014 /"LNEBFC" - LINE BUFFER COUNT TO THE MAX # OF CHAR. IN THIS WAY /A014 /THE WHOLE INPUT LINE, UP TO THE OVERFLOW, CAN BE PUT UP ON THE /A014 /SCREEN WHEN THE ERROR MESSAGE IS REPORTED TO THE USER. /A014 AC7777 / YES: GET MAX SIZE OF INPUT LINE BUFFER /A014 DCA LNEBFC /SET LINE BUF CHAR COUNT IN "RDLNBF" TO MAX SIZE/A014 /DOUBLE INCREMENT "LNETSZ" TO RETURN MATH CTRL BLOCK OVFLW ERROR/A010 ISZ LNETSZ /SINCE IT IS A MATH CTRL BLOCK, PROCESS AS /A010 / MTH CTRL BLK INPUT LINE BUF OVFLW ERROR /A010 / DOUBLE INCREMENT PC TO RETURN MTH ERROR /A010 NOTMTH, ISZ LNETSZ /SINGLE INCREMENT PC TO RETURN AS NOT MATH BLOCK/A010 TAD (EVFLW6 /GET INPUT LINE BUF OVERFLOW ERROR VALUE INTO AC/A010 JMP I LNETSZ /RETURN TO CALLER /A010 /RTN TO INCREMENT PTR AND TEST FOR OVERFLOW OF WORK BUFFER. IF THE WORK /A010 /BUFFER NOT OVERFLOWED THEN A NORMAL RETURN IS MADE. IF IT IS THEN A /A010 /CHECK IS MADE TO SEE IF IT IS THE FIRST LINE OF THE CONTROL BLOCK. /A010 /IF IT IS THE FIRST LINE THEN THE RETURN IS SET TO PROCESS AS NOT BEING /A010 /A MATH CTRL BLK. IF IT IS NOT THE FIRST LINE THEN MUST BE MATH BLOCK /A010 /OTHERWISE COULD NOT HAVE GOTTEN THAT FAR SO PROCESS AS MATH CTRL BLOCK /A010 /WORK BUFFER OVERFLOW ERROR /A010 WRKTSZ, XX / ISZ WRKPTR /INCREMENT WORK BUFFER POINTER TAD (-UPWRK /GET UPPER LIMIT OF WORK BUFFER TAD WRKPTR /GET LATEST ADDR AVAILABLE IN WORK BUFFER SPA CLA /IS THE WORK BUFFER OVERFLOWED? JMP I WRKTSZ / NO: JUST RETURN TO CALLER /M010 TAD FSTLNE / YES: GET "CONTROL BLOCK 1ST LINE" FLAG /A010 SZA CLA /IS IT THE FIRST LINE OF THE BLOCK? /A010 JMP OVWKBF / NO: THEN MATH CTRL BLK WRK BUFF OVERLOW ERROR/A010 ISZ WRKTSZ / YES: DOUBLE SET PC &RTRN TO DUMP NOT MATH BLK/A010 OVWKBF, ISZ WRKTSZ /SINGLE BUMP PC TO RTRN WRK BUF OVERFLOW ERROR /A010 TAD (EVFLW7 /GET MATH WORK BUFFER OVRFLW ERROR VALUE INTO AC/A010 JMP I WRKTSZ /RETURN TO CALLER /A010 /ROUTINE TO HANDLE "BEGIN" CONTROL WORD IN EDITOR MATH CONTROL BLOCK /A020 BEGIN, XX JMS CHKLNE /CHK FOR NON-ALLOWABLE CHARS ON SAME LINE AS... /A024 /....AND RIGHT AFTER CONTROL WORD /A024 JMP ERRBCK /RETURN HERE FROM "CHKLNE" WITH ERROR NUM IN AC /A026 /.. TO PASS BACK IF NON-LEGAL CHARS FOUND ON LNE/A026 TAD MTHWRK /GET EDITOR MATH WORK AREA FLAG /M033 SNA CLA /ARE WE JUST BEGINNING AN EDITOR MATH WORK AREA?/M033 JMP ERROR3 / NO: RETURN ERROR - MATH AREA ALREADY BEGUN /M033 /THE FOLLOWING ERROR MIGHT NEVER BE REPORTED BECAUSE IT WILL /BE SUPERCEDED BY TRAPPING OUT THE PREVIOUS ERROR FIRST. HERE /FOR INSURANCE ANYWAY. TAD MTHSND / YES: GET MATH CTRL BLOCK SECOND LINE FLAG /M033 SZA CLA /ARE WE PROCESSING THE SECOND LINE? /M033 JMP ERROR4 / NO: REPORT ERROR - "BEGIN" ON WRONG LINE /M033 /DO FULL INITIALIZATION AT START OF EDIT MATH WORK AREA - BECOMES /A020 /MEANINGFUL WHEN HAVE TO BACK UP TO START OF MATH WORK AREA AND /A020 /REPROCESS EDIT MATH WORK AREA , OR IF FIND OTHER MATH WORK AREAS IN /A020 /SAME DOCUMENT /A020 AC0001 / YES: PUT 1 IN AC TO SET "MTHTYP" IN "RTRN4" /A020 JMS RTRN4 / YES: CALL MATH INITIALIZATION ROUTINES /A020 /ONCE RETURNED FROM "RTRN4" HAVE TO RESET "START OF EDIT MATH WORK AREA"/A020 /FLAG = TRUE BECAUSE NOT LIKE INITIALIZATION TIME ONCE GET THIS FAR /A020 /MEANS MUST BE IN MATH WORK AREA. ALSO MUST RESET "IN CONTROL BLOCK" /A020 /FLAG IN EDITOR MATH CODE IN LP FIELD BACK TO TRUE BECAUSE ONCE GET THIS/A020 /FAR MUST BE IN CTRL BLOCK TOO! /A020 DCA MTHWRK /RESET "START OF EDIT MATH WORK AREA"=TRUE /A020 CDFLP /CHANGE TO LP DATA FIELD /A020 DCA I (INCTLB /RESET "IN CONTROL BLOCK" = TRUE /A020 /D034 /SET BEGFLG FLAG TO TELL MTHBEG ROUTINE IN THE EDITOR TO SCROLL /A027 /D034 /BACK TO THE TOP OF THE CTRL BLOCK & INSERT THE MATH_BEGIN CODE. /A027 /D034 /THIS WILL HAPPEN NEXT TIME THE EDITOR GOES TO EINEXT ROUTINE. /A027 /D034 AC0001 / /A027 /D034 DCA I (BEGFL) /SET FLAG (IN LP FIELD) /A027 CDFMYF /RETURN TO MATH DATA FIELD ISZ BEGIN /SET UP SKIP FOR NORMAL RETURN /A027 JMP I BEGIN /RETURN TO CALLER /A027 ERROR4, TAD (EVSYN4-EVSYN3 /RTRN "BEGIN" ON WRONG LINE ERROR /M027 ERROR3, TAD (EVSYN3 /RTRN EDIT MATH WORK AREA ALREADY BEGUN ERR /M024 JMP I BEGIN /RETURN TO CALLER WITH ERROR NUMBER IN AC /A021 /**************************************************************************** / FLGCTL Moved here from location in LEXASC to create space /a044 /**************************************************************************** / FLaG_ConTroL / Enter with AC bits set to NUMFLG bits you want disabled. FLGCTL, XX CMA AND NUMFLG / AND NUMFLG with complemented bits in AC DCA NUMFLG / update NUMFLG JMP I FLGCTL X=. / INDICATE FIRST FREE LOCATION /A041 / ------------------ PAGE / /++ / "CMDPSR" - COMMAND PARSER / /FUNTIONAL DESCRIPTION: CMDPSR / /PSEUDO-CODE DESCRIPTION: / / COMMAND PARSER PSUEDO-CODE / /START PROGRAM / SAVE PASSED STARTING ADDRESS OF INPUT_WORD / SAVE " " " " SYMBOL_TABLE / INITIALIZE SYMBOL_TABLE_POINTER / INITIALIZE SYMBOL_TABLE_WORD_COUNTER = 0 / SAVE PASSED INPUT STRING CHARACTER LENGTH AS - INPUT_WORD_LENGTH / INCREMENT STARTING ADDRESS OF INPUT_WORD (TO FIRST CHAR OF INPUT STRING) / DO WHILE SEARCH NOT DONE / | INITIALIZE INPUT_STRING_POINTER / | INITIALIZE INPUT_STRING_CHARACTER_LENGTH_COUNTER = - INPUT_WORD_LENGTH / | INCREMENT SYMBOL_TABLE_WORD_COUNTER / | DO WHILE CHARACTER COMPARISON NOT DONE / | | IF INPUT_WORD_CHARACTER <> SYMBOL_TABLE_WORD_CHARACTER / | | | THEN / | | | CHARACTER COMPARISON DONE / | | | DO WHILE SYMBOL_TABLE_WORD_CHARACTER NOT NEGATIVE / | | | | INCREMENT SYMBOL_TABLE_POINTER / | | | | ENDD0 / | | | INCREMENT SYMBOL_TABLE_POINTER / | | | IF SYMBOL_TABLE_WORD_CHARACTER = 0 / | | | | THEN SEARCH DONE / | | | | ENDIF / | | | ELSE / | | | INCREMENT SYMBOL_TABLE_POINTER / | | | INCREMENT INPUT_STRING_POINTER / | | | INCREMENT INPUT_STRING_CHARACTER_COUNTER / | | | IF INPUT_STRING_CHARACTER_COUNTER = 0 / | | | | THEN SEARCH DONE / | | | | CHARACTER COMPARISON DONE / | | | | ENDIF / | | | ENDIF / | | ENDDO / | ENDDO / RETURN STATUS OF WORD COMPARED /END PROGRAM / / / /CALLING SEQUENCE: JMS CMDPSR / / /INPUT PARAMETERS: COME INTO THIS RTN WITH THE FOLLOWING / VALUES SET RIGHT AFTER THE CALL / JMS CMDPSR /THE CALL... / /...MADE TO THE COMMAND PARSER / XXXXX /#1 - THE ADDR OF THE START OF THE INPUT STRING TO BE COMPARED, / / ALONG WITH IT'S LENGTH IN THE FIRST LOC OF THAT STRING. / YYYYY /#2 - THE ADDR OF THE START OF THE SYMBOL TBLE WITH WHICH TO / / RUN THE COMPARISON. / / /IMPLICIT INPUT: RTNVAL / /OUTPUT PARAMETERS: VALUE IN THE AC / / IF THERE IS A MATCH THEN THIS ROUTINE PASSES BACK TO / THE CALLER IN THE AC THE NUMBER OF THE WORD IN THE / SYMBOL TABLE THAT HAS BEEN MATCHED. / IF THERE IS NO MATCH THEN THIS ROUTINE PASSES BACK TO / THE CALLER A ZERO VALUE IN THE AC. / /IMPLICIT OUTPUT: NONE / /COMPLETION CODE: NONE / /SIDE EFFECTS: NONE / /-- / /COMMAND PARSER ROUTINE CMDPSR, XX /MATH CONTROL BLOCK PARSER ROUTINE / CLA /CLEAR AC TAD I CMDPSR /GET LEAD ADDR OF INPUT STRING ROUTINE DCA SAVLOC /SAVE IT ISZ CMDPSR /INCREMENT PC TO SET UP FOR NEXT PARAMETER PASSED TAD I CMDPSR /GET LEAD ADDR OF SYMBOL TABLE TO BE USED DCA TEMPS4 /SAVE IT DCA RTNVAL /INITIALIZE SYMBOL TABLE WORD COUNTER TO ZERO ISZ CMDPSR /INCREMENT PC TO SET UP FOR RETURN TO CALLER TAD I SAVLOC /GET INPUT STRING CHARACTER LENGTH CIA /GET NEGATIVE AND DCA HLDSTN /SAVE AS INPUT STRING CHARACTER LENGTH ISZ SAVLOC /MOVE INPUT STRING CHARACTER POINTER TO FIRST CHAR /COMPARE INPUT WORD WITH WORD FROM SYMBOL NEXT2, TAD SAVLOC /GET START OF INPUT STRING DCA SAVTMP /INITIALIZE POINTER TO INPUT STRING TAD HLDSTN /GET INPUT STRING SIZE COUNTER /A038 DCA HLDST1 /INITIALIZE INPUT STRING CHAR COUNTER /A038 ISZ RTNVAL /INCREMENT SYMBOL TABLE WORD COUNTER NEXT3, TAD I SAVTMP /GET A CHARACTER FROM INPUT STRING AND (LOWMSK /IF CHAR IS LOWER CASE THAN STRIP AWAY LOWER CASE BIT CIA /GET IT'S NEGATIVE TAD I TEMPS4 /GET CHARACTER FROM SYMBOL TABLE SZA CLA /DO THE CHARACTERS MATCH? JMP MOVWRD / NO: GO MOVE TO START OF NEXT WORD IN SYMBOL TABLE ISZ SAVTMP / YES: INCREMENT INPUT STRING POINTER ISZ TEMPS4 /INCREMENT SYMBOL TABLE POINTER ISZ HLDST1 /IS IT THE END OF THE INPUT STRING? /M038 JMP NEXT3 / NO: GET NEXT SET OF CHARACTERS TO TRY MATCHUP / YES: THEN HANDLE INPUT WORD MATCHUP WITH SYMBOL TBL TAD RTNVAL /GET NUMBER OF SYMBOL TABLE WORD MATCHED AND BYENOW, JMP I CMDPSR /RETURN TO CALLER /SET UP SYMBOL TABLE POINTER FOR BEGINNING OF NEXT WORD MOVWRD, TAD I TEMPS4 /GET LAST CHARACTER CHECKED IN SYMBOL TABLE ISZ TEMPS4 /SET SYMBOL TABLE POINTER TO START OF NEXT WORD /A041 SMA CLA /IS IT A NEGATIVE (i.e. END OF WORD IN SYM TBL)?/A041 JMP MOVWRD / NO: THEN CHECK AGAIN UNTIL END OF WORD FOUND /A041 / YES: GO SET UP POINTER FOR NEXT WORD IN SYM TBL /D041 SPA CLA /IS IT A NEGATIVE (i.e. END OF THAT WORD IN SYM TBL)? /D041 JMP NEWRTN / YES: GO SET UP POINTER FOR NEXT WORD IN SYM TBL /D041 ISZ TEMPS4 / NO: THEN MOVE DOWN A CHARACTER....... /D041 JMP MOVWRD /......AND CHECK AGAIN UNTIL END OF WORD FOUND /D041 NEWRTN, ISZ TEMPS4 /SET SYMBOL TABLE POINTER TO START OF NEXT WORD /CHECK FOR END OF SYMBOL TABLE TAD I TEMPS4 /GET FIRST LETTER OF NEXT WORD IN SYMBOL TABLE SNA CLA /IS IT THE END OF THE SYMBOL TABLE? JMP BYENOW / YES: GO EXIT WITH ZERO IN AC FOR NO MATCH FOUND JMP NEXT2 / NO: GO COMPARE INPUT STRING TO NEXT WORD IN SYM TBL /VALUES USED IN COMMAND PARSER ROUTINE TEMPS4, 0 /POINTER TO PASSED SYMBOL TABLE SAVLOC, 0 /STORE STARTING ADDR OF INPUT STRING SAVTMP, 0 /STORE POINTER TO INPUT STRING RTNVAL, 0 /SYMBOL TABLE WORD COUNTER HLDSTN, 0 /NEGATIVE OF INPUT STRING LENGTH HLDST1, 0 /INPUT STRING CHAR COUNTER /A038 LOWMSK=4137 /MASK TO ELIMINATE BIT SIGNIFYING LOWER CASE CHARACTER /ITLZ ROUTINES MOVED TO ANOTHER PAGE FOR SPACE REASONS /D041 /BEGIN, MOVED TO ANOTHER PAGE FOR ROOM /D041 /END, MOVED TO ANOTHER PAGE FOR ROOM /D027 /TOTAL, MOVED TO ANOTHER PAGE FOR ROOM /D041 / THE FOLLOWING BUFFERS OF 123 LOCATIONS WERE MOVED TO TMATH FOR SPACE /A041 /STRING NUMBER BUFFERS USED BY LEXASC /A041 MAX=20 /DEFINE LENGTH OF MAX AREA FOR Z-BLOCK /A041 B, ZBLOCK MAX+3 /A041 C, ZBLOCK MAX+MAX /A041 SAC, ZBLOCK MAX+MAX /A041 X=. / INDICATE FIRST FREE LOCATION /A041 / ------------------ PAGE / /++ / "XLTFRM" - INFIX TO POSTFIX TRANSLATOR / /FUNTIONAL DESCRIPTION: XLTFRM / /PSEUDO-CODE DESCRIPTION: THIS PSEUDO-CODE EXPLAINS THE FORMATTING / OPERATIONS OF THE TRANSLATOR CODE WHERE / EVERYTHING TO THE LEFT OF AND INCLUDING THE / EQUAL SIGN IS PUT INTO POLISH NOTATION. / /INITIALIZE OPERATOR HANDLING STACK TO EMPTY /PUSH "=" DELIMITER ONTO STACK-MATCHES END OF FORMULA TOKEN VALUE & PRECEDENCE /SET "OPERAND EXPECTED" = TRUE /SET "NEXT INPUT PROCESSED" = TRUE /DO WHILE STACK NOT EMPTY / | IF "NEXT INPUT PROCESSED" = TRUE / | THEN INPUT NEXT INPUT / | ENDIF / | "NEXT INPUT PROCESSED" = FALSE / | IF "OPERAND EXPECTED" = TRUE / | |THEN / | | IF NEXT INPUT IS AN OPERAND / | | | THEN / | | | OUTPUT NEXT INPUT TO POLISH STRING / | | | SET "OPERAND EXPECTED" = FALSE / | | | SET "NEXT INPUT PROCESSED" = TRUE / | | | ELSE / | | | IF NEXT INPUT = "(" / | | | | THEN PUSH NEXT INPUT INTO OPERATOR STACK / | | | | ELSE / | | | | IF NEXT INPUT = UNARY OPERATOR / | | | | | THEN / | | | | | IF NO UNARY OPERATOR ON TOP OF STACK / | | | | | | THEN PUSH UNARY OPRTR & PRECEDENCE ON STK / | | | | | | ELSE OUTPUT OPERAND NOT RECEIVED ERROR / | | | | | | ENDIF / | | | | | ELSE OUTPUT OPERAND NOT RECEIVED ERROR / | | | | | ENDIF / | | | | ENDIF / | | | SET "NEXT INPUT PROCESSED" = TRUE / | | | ENDIF / | |ELSE / | | IF NEXT INPUT IS AN OPERATOR / | | | THEN / | | | CASE PRECEDENCE NEXT INPUT LESS/EQUAL/OR GREATER THAN TOP OF STK / | | | | LOWER / | | | | IF TOP OF STACK = "(" / | | | | | THEN / | | | | | OUTPUT "TOO MANY LEFT PARENTHESIS" / | | | | | ELSE / | | | | | POP STACK AND OUTPUT TO POLISH STRING / | | | | | ENDIF / | | | | EQUAL / | | | | IF TOP OF STACK = "(" / | | | | | THEN / | | | | | POP STACK / | | | | | SET "NEXT INPUT PROCESSED" = TRUE / | | | | | ELSE / | | | | | POP STACK AND OUTPUT TO POLISH STRING / | | | | | ENDIF / | | | | HIGHER / | | | | IF NEXT INPUT = ")" / | | | | | THEN / | | | | | OUTPUT "TOO MANY RIGHT PARENTHESIS" / | | | | | ELSE / | | | | | PUSH NEXT INPUT INTO OPERATOR STACK / | | | | | SET "OPERAND EXPECTED" = TRUE / | | | | | ENDIF / | | | | SET "NEXT INPUT PROCESSED" = TRUE / | | | | END CASE / | | | ELSE / | | | OUTPUT "OPERATOR NOT RECEIVED" / | | | ENDIF / | | ENDIF / | ENDDO / / /CALLING SEQUENCE: JMS XLTFRM / /INPUT PARAMETERS: NONE / /IMPLICIT INPUT: TOKVAL, / /OUTPUT PARAMETERS: MATH OVERFLOW & SYNTAX ERROR NUMBERS IN THE AC / /IMPLICIT OUTPUT: SYMTBL,MTHTBL,OUTLST,RESULT / /COMPLETION CODE: NONE / /SIDE EFFECTS: NONE / /-- / /THE FOLLOWING ROUTINE CONTAINS THE TRANSLATOR CODE FOR THE MATH PACKAGE. /IT IS CALLED FROM A HIGHER ROUTINE WHEN THERE IS A NEED TO CHANGE A MATH /CONTROL BLOCK FORMULA FROM INFIX TO POSTFIX FORMAT. IF THERE ARE ANY ERRORS /IN CONJUNCTION WITH THE SCANNING AND/OR TRANSLATION PROCESS THEY ARE RETURNED /TO THE CALLING ROUTINE AS A CODED NUMBER IN THE AC WITHOUT A SKIP JUMP RETURN XLTFRM, XX /TRANSLATION FROM INFIX TO POSTFIX ROUTINE CLA /CLEAR AC JMS INTLZE /PUT DELIMITER IN STACK, INITIALIZE PTRS, AND FLAGS /DO WHILE STACK NOT EMPTY DOWHLE, JMS EMPTY /CHECK TO SEE - IS STACK EMPTY? JMP ASGNMT / YES: GO HANDLE ASSIGNMENT VALUE JMS TSTINP / NO: GO TO INPUT AND PROCESSING ROUTINE JMS OPERND /GO PROCESS IF INPUT IS OPERAND OR OPERATOR JMP DOWHLE /LOOP BACK TO CONTINUE PROCESSING /NUMBER OF DIFFERENT ERRORS ENCOUNTERED IN THE SCANNER AND /TRANSLATOR RETURNED TO THE CALLER VIA THE AC ERRTKN, TAD TOKVAL /GET ERROR # PASSED FROM LEXIC JMP RTNERR /GO EXIT TRANSLATOR ROUTINE /SYNTAX ERRORS SYNR11, TAD (EYNR11-EYNER6 /FORMULA FORMAT SYNTAX ERROR /A008 SYNER6, TAD (EYNER6-EYNER5 /OPERAND VARIABLE EXPECTED NEXT & NOT RECEIVED SYNER5, TAD (EYNER5-EYNER4 /FORMAT OR END OF FORMULA EXPECTED & NOT REC'D SYNER4, TAD (EYNER4-EYNER3 /TOO MANY RIGHT PARENTHESIS SYNER3, TAD (EYNER3-EYNER2 /TOO MANY LEFT PARENTHESIS SYNER2, TAD (EYNER2-EYNER1 /OPERATOR EXPECTED NEXT BUT NOT RECEIVED SYNER1, TAD (EYNER1-EVFLW5 /OPERAND EXPECTED NEXT BUT NOT RECEIVED /DATA STRUCTURE OVERFLOW ERRORS OVFLW5, TAD (EVFLW5-EVFLW4 /RESULT PTR TBL OVRFLW ERROR /A001 OVFLW4, TAD (EVFLW4-EVFLW3 /OUTPUT LIST (POLISH STRING) OVERFLOW ERR OVFLW3, TAD (EVFLW3-EVFLW2 /SYMBOL TABLE OVERFLOW ERROR /NOTE: PRESENTLY (V1.2.2) ERROR "OVFLW2" CANNOT TAKE PLACE BECAUSE OF THE /RELATIVE SIZE OF THE SYMBOL TABLE TO THE SYMBOL POINTER TABLE. A SYMBOL /TABLE OVERFLOW WILL ALWAYS OCCUR BEFORE THE SYMBOL POINTER TABLE CAN /OVERFLOW. (ref. WPF1.PA & WPMN2.PA - "EVFLW2"). OVFLW2, TAD (EVFLW2-EVFLW1 /SYMBOL PTR TABLE OVRFLW ERR (SEE ABOVE NOTE) OVFLW1, TAD (EVFLW1 /STACK OVERFLOW ERROR RTNERR, JMP ERRBCK /GO EXIT TRANSLATOR ROUTINE WITH ERROR # IN AC /EXIT TRANSLATOR ROUTINE EXTXLT, ISZ XLTFRM /SKIP JMP BACK FOR NORMAL RETURN JMP I XLTFRM /RETURN TO CALLER / /++ / "ASGNMT" - ASSIGNMENT ROUTINE / /FUNTIONAL DESCRIPTION: ASGNMT / /PSEUDO-CODE DESCRIPTION: NOTE: FOLLOWING PSEUDO-CODE HANDLES EVERYTHING / TO THE RIGHT OF THE EQUAL SIGN, AND THEN ONLY / AFTER THE INFIX TO POSTFIX TRANSLATION HAS / COMPLETED ON EVERYTHING TO THE LEFT OF THE / EQUAL SIGN. / /SET "NEXT INPUT PROCESSED" FLAG = TRUE /SET "OPERAND EXPECTED NEXT" = TRUE /INPUT NEXT INPUT /IF NEXT INPUT IS AN OPERAND VARIABLE / | THEN / | OUTPUT NEXT INPUT TO POLISH STRING / | SET "NEXT INPUT PROCESSED" FLAG = TRUE / | ELSE / | OUTPUT SYNTAX ERROR "OPERAND VARIABLE EXPECTED NEXT BUT NOT RECEIVED" / | ENDIF /INPUT NEXT INPUT /IF NEXT INPUT IS A FORMAT STATEMENT / | THEN / | PROCESS FORMAT STATEMENT / | SET "NEXT INPUT PROCESSED" FLAG = TRUE / | INPUT NEXT INPUT / | ENDIF /IF NEXT INPUT IS NOT AN "END OF FORMULA" / | THEN / | OUTPUT SYNTAX ERROR "END OF FORMULA EXPECTED BUT NOT RECEIVED" / | ENDIF / / /CALLING SEQUENCE: JMP ASGNMT / /INPUT PARAMETERS: NONE / /IMPLICIT INPUT: TOKVAL,SVDFLC,DFAULT / /OUTPUT PARAMETERS: NONE / /IMPLICIT OUTPUT: SYMTBL,MTHTBL,RESULT,OUTLST,POSTFX / /COMPLETION CODE: NONE / /SIDE EFFECTS: NONE / /-- / /SENT HERE IF TRANSLATION OF LEFT SIDE OF FORMULA WENT OKAY. THE FOLLOWING /RTN IS USED TO SERVICE THE ASSIGNMENT VALUE TO THE RIGHT OF THE EQUAL SIGN ASGNMT, CLA /SET AC TO ZERO DCA NXTPRS /SET "NEXT INPUT PROCESSED" FLAG = TRUE DCA OPDNXT /SET "OPERAND EXPECTED NEXT" FLAG = TRUE JMS TSTINP /CALL LEXIC AND REQUEST NEXT INPUT /DO A CHECK HERE TO SEE IF USER PUT A HARD RETURN RIGHT AFTER /A016 /THE "=" SIGN IN THE EQUATION. IF SO IT IS TRAPPED OUT TO BE /A016 /REPORTED BACK TO THE USER TO MAKE HIM AWARE OF THIS /A016 TAD TOKEN /GET INPUT TOKEN PASSED BACK FROM LEXIC /A032 TAD (-OPERAT /GET NEGATIVE OF OPERATOR TOKEN /A032 SZA CLA /IS THE TOKEN PASSED BACK AN OPERATOR? /A032 JMP ASGNM1 / NO: THEN CONTINUE TO PROCESS INPUT /A032 TAD TOKVAL / YES: GET ASCII VALUE OF OPERATOR PASSED BACK /A016 TAD (-ECNWLN /GET NEGATIVE OF END OF LINE (HARD RETURN) /A016 SNA CLA /IS THE OPERATOR A HARD RETURN? /A016 JMP SYNR11 / YES: SYNTAX ERROR - FORMULA FORMAT INCORRECT /A016 / NO: IF HARD RETURN NOT FOUND THEN COME HERE /A016 / TO CONTINUE PROCESSING INPUT /A016 ASGNM1, TAD TOKEN /GET INPUT TOKEN PASSED BACK /M032 TAD (-OPERAN /GET NEGATIVE OF OPERAND VARIABLE TOKEN SZA CLA /IS INPUT TOKEN AN OPERAND VARIABLE? JMP SYNER6 / NO: SYNTAX ERROR "OPERAND VARIABLE NOT RECEIVED" JMS OPERND / YES: PROCESS IT & PUT VALUE ADDR IN OUTPUT LIST JMS RLTOUT /PUT ASSIGNMENT OPERAND INFO INTO RESULT PTR TBL /A001 JMS TSTINP /CALL LEXIC AND REQUEST NEXT INPUT TAD TOKEN /GET INPUT TOKEN PASSED BACK TAD (-FORMAT /GET NEGATIVE OF FORMAT STATEMENT SZA CLA /IS IT A FORMAT STATEMENT TOKEN? JMP ENDTKN / NO: SEE IF IT IS AN "END OF FORMULA" TOKEN / YES: DO FORMAT CHECK ROUTINE /A009 /IF FORMAT STATEMENT IS PART OF A "SET" COMMAND /A039 /THEN ALWAYS PROCESS THE FORMAT. IF NOT THEN /A039 /CHECK IF USER FORMAT ALREADY SPECIFIED FOR THE /A009 /ASSIGNMENT VARIABLE FROM A PREVIOUS CTRL WORD /A009 /STATEMENT. CANNOT HAVE TWO DIFFERENT USER /A009 /SPECIFIED FORMATS IN THE SAME CTRL BLOCK FOR /A009 /THE SAME RESULT VARIABLE CAUSE OF MATH ERRORS /A009 TAD I SVDFLC /GET PRESENT FORMAT SETTING OF ASSIGNMENT VAR /A009 CIA /GET IT'S NEGATIVE /A009 TAD (DFAULT /ADD TO IT DFAULT FORMAT SETTING /A009 SZA CLA /HAS THE USER ALREADY SPECIFIED A FORMAT /A009 TAD SETFLG / YES: BUT FIND OUT WHAT KIND OF COMMAND /A039 SZA CLA / IS THIS A FORMULA COMMAND /A039 JMP SKPFMT / YES: IGNORE IT - FORMAT ALREADY SPECIFIED /A009 / NO: DO FORMAT STATEMENT PROCESSING ROUTINE TAD TOKVAL /GET FORMAT STATEMENT PASSED FROM LEXIC DCA I SVDFLC /OVERWRITE IT INTO LOCATION OF DEFAULT FORMAT ..../M007 /SETTING OF ASSIGNMENT VALUE OF INPUT OPERAND VARIABLE SKPFMT, DCA NXTPRS /SET "NEXT INPUT PROCESSED" = TRUE JMS TSTINP /CALL SCANNER AND REQUEST NEXT INPUT /END OF FORMULA PROCESSING ROUTINE ENDTKN, TAD TOKVAL /GET INPUT FROM TOKVAL INTO AC TAD (-ECNWLN /GET NEGATIVE OF END OF LINE (HARD RETURN) SZA CLA /IS IT THE END OF THE FORMULA? JMP SYNER5 / NO: SYNTAX ERROR "END OF FORMULA NOT RECEIVED" /PLACE JMP I OUTEXT AT END OF OUTPUT LIST SO IT CAN BE /USED AS A SUBROUTINE BY THE EXECUTION CODE TAD (JMP I OUTEXT /GET VALUE OF JMP I OUTEXT DCA I OUTPTR /SAVE IT AT THE END OF THE OUTPUT LIST /GO SET UP TO LEAVE THE TRANSLATOR JMP EXTXLT / YES: GO EXIT XLTFRM ROUTINE (i.e. TRANSLATOR) SVDFLC, 0 /POINTER TO LOCATION OF FORMAT STATEMENT OF /A007 /LAST OPERAND PROCESSED. SET UP BY 'MATCH' /A007 /OR 'SYMADD' ROUTINES /A007 SETFLG, 0 /FLAG WORD USED TO DETERMINE IF FORMAT SHOULD /A039 /BE PROCESSED. SETFLG = 0 FOR A SET COMMAND /A039 /AND SETFLG = 1 FOR A FORMAT COMMAND. /A039 /SINCE A SET STATEMENT ABSOLUTELY CHANGES THE /A039 /VALUE OF AN OUTPUT VARIABLE, IT'S FORMAT CAN'T /A039 /AFFECT THE ACCURACY OF ANY CALCULATIONS IN /A039 /PROGRESS. CHANGING THE FORMAT OF A FORMULA /A039 /OUTPUT VARIABLE CAN CAUSE INACCURACIES BY /A039 /INTRODUCING ROUNDING ERRORS. /A039 /THIS SUBOUTINE PLACES INPUT FORMULA ASSIGNMENT OPERAND VARIABLE PTR TO /A001 /START OF NAME INTO RESULT PTR TBL AFTER CHECKING TO SEE THAT A COPY OF /A001 /IT IS NOT THERE ALREADY. IF ONE IS THEN A RETURN IS MADE TO THE /A001 /CALLER WITHOUT FURTHER ACTION. /A001 /FIRST CHECK TO SEE IF ALREADY HAVE NAME IN RESULT PTR TBL /A001 RLTOUT, XX /OUTPUT TO RESULT PTR TABLE RTN /A001 TAD (RESULT /INITIALIZE TEMPORARY POINTER TO RESULT TBL /A001 DCA TMPTR1 /AND SAVE /A001 BCKOVR, TAD TMPTR1 /GET IT BACK AND /A001 CIA /CHECK TO SEE IF IT /A001 TAD RESPTR /IS THE END OF /A001 SNA CLA /THE RESULTS PTR TBL? /A001 JMP INJECT / YES: GO HANDLE ACCORDINGLY /A001 TAD NMEPTR / NO: GET INPUT OPERAND VARIABLE NAME PTR /A001 CIA /GET IT'S NEGATIVE /A001 TAD I TMPTR1 /GET OPRND VARIABLE NAME PTR FROM RESULT PTR TBL /A001 SNA CLA /IS THE PTR ALREADY IN THE TABLE? /A001 JMP SPLIT / YES: THEN GO EXIT RTN WITHOUT DOING ANYTHING /A001 ISZ TMPTR1 / NO: SET UP FOR NEXT OPRND VARIABLE NAME PTR /A001 JMP BCKOVR /GO COMPARE INPUT WITH NEXT PTR FROM TABLE /A001 /PLACE PTR TO UNMATCHED ASSIGNMENT OPERAND NAME INTO RSLT PTR TBL/A001 INJECT, TAD NMEPTR /GET PTR TO ASSIGNMENT OPERAND VARIABLE NAME /A001 DCA I RESPTR /PLACE IT IN THE RESULT PTR TBL /A001 JMS RESTSZ /INCREMENT RESULT PTR TBL PTR & CHK FOR OVERFLOW /A001 SPLIT, JMP I RLTOUT /RETURN TO CALLER /A001 /THE FOLLOWING ROUTINE IS USED TO INCREMENT THE STACK POINTER AND PUSH /A VALUE ONTO THE OPERATOR HANDLING STACK. THE VALUE TO BE PUT ON THE STACK /IS PASSED TO THE ROUTINE VIA THE AC WHEN A CALL IS MADE TO THIS ROUTINE. /THIS ROUTINE ALSO CHECKS FOR A OPERATOR HANDLING STACK OVERFLOW ERROR. PSHSTK, XX /"PUSH ON TO THE STACK" ROUTINE ISZ POSTSP /INCREMENT STACK POINTER DCA I POSTSP /PUSH VALUE PASSED IN THE AC ON TO THE STACK TAD (-UPOPSK /GET NEGATIVE OF UPPER LIMIT OF OPERATOR STACK TAD POSTSP /GET SIZE OF STACK POINTER SNA CLA /IS THERE A STACK OVERFLOW CONDITION? JMP OVFLW1 / YES: GO PROCESS STACK OVERFLOW ERROR JMP I PSHSTK / NO: RETURN TO CONTINUE PROCESSING /THIS ROUTINE CLEARS TOP OPERATOR & IT'S PRECEDENCE OFF STACK FLSHST, XX /FLUSH TOP OF STACK ROUTINE JMS POPSTK /GET PRECEDENCE OFF STACK JMS POPSTK /GET OPERATOR OFF STACK CLA /THROW AWAY VALUE RETURNED IN AC JMP I FLSHST /RETURN TO CALLER /D041 /ROUTINE TO INCREMENT SYMBOL POINTER TABLE POINTER AND TEST FOR OVERFLOW /D041 MTHTSZ, XX /SYM PTR TBL PTR INCREMENT AND OVERFLOW TEST /D041 ISZ MTHPTR /INCREMENT SYM PTR TBL POINTER /D041 TAD (-UPMTH /GET NEGATIVE OF SYM PTR TBL UPPER LIMIT /D041 TAD MTHPTR /GET ADDRESS IN POINTER TO TABLE /D041 SNA CLA /IS THERE AN OVERFLOW? /D041 JMP OVFLW2 / YES: GO PROCESS SYMBOL PTR TABLE OVERFLOW ERROR /D041 JMP I MTHTSZ / NO: RETURN TO CONTINUE PROCESSING /SYMTSZ, MOVED HERE ON EDIT 041 FOR SPACE REASONS /ROUTINE TO OUTPUT CHAR TO SYMBOL TABLE AND INCREMENT SYMBOL TABLE /M005 /POINTER AND TEST FOR OVERFLOW SYMTSZ, XX /SYM TABLE PTR INCREMENT AND OVERFLOW TEST DCA I SYMPTR /OUTPUT CHAR PASSED IN AC TO SYMBOL TABLE /A005 ISZ SYMPTR /INCREMENT SYMBOL TABLE POINTER TAD (-UPSMTB /GET NEGATIVE OF SYM TABLE UPPER LIMIT TAD SYMPTR /GET ADDRESS IN POINTER TO TABLE SNA CLA /IS THERE AN OVERFLOW? JMP OVFLW3 / YES: GO PROCESS SYMBOL TABLE OVERFLOW ERROR JMP I SYMTSZ / NO: RETURN TO CONTINUE PROCESSING X=. / INDICATE FIRST FREE LOCATION /A041 / ------------------ PAGE /ROUTINE TO INCREMENT OUTPUT LIST POINTER AND TEST FOR OVERFLOW /SAVES VALUE PASSED TO IT IN THE AC THEN BUMPS AND TESTS POINTER OUTTSZ, XX /OUTPUT LIST PTR INCREMENT AND OVERFLOW TEST DCA I OUTPTR /PLACE PASSED VALUE IN OUTPUTLIST ISZ OUTPTR /INCREMENT OUTPUT LIST POINTER TAD (-UPOPLT /GET NEGATIVE OF OUTPUT LIST UPPER LIMIT TAD OUTPTR /GET ADDRESS IN POINTER TO TABLE SNA CLA /IS THERE AN OVERFLOW? JMP OVFLW4 / YES: GO PROCESS OUTPUT LIST OVERFLOW ERROR JMP I OUTTSZ / NO: RETURN TO CONTINUE PROCESSING /RTN INCREMENTS RESULT PTR TBLE PTR, TESTS FOR OVERFLOW, & INITS NXT LOC/A001 RESTSZ, XX /RESULT PTR TBL PTR INCREMENT AND OVERFLOW TEST /A001 ISZ RESPTR /INCREMENT RESULT POINTER TABLE POINTER /A001 TAD (-UPRES /GET NEGAIIVE OF RESULT PTR TABLE UPPER LIMIT /A001 TAD RESPTR /GET ADDRESS IN POINTER TO TABLE /A001 SNA CLA /IS THERE AN OVERFLOW? /A001 JMP OVFLW5 / YES: GO PROCESS RESULT PTR TABLE OVERFLOW /A001 DCA I RESPTR / NO: INIT NEXT LOC IN RESULT PTR TBL TO ZERO /A001 JMP I RESTSZ / NO: RETURN TO CONTINUE PROCESSING /A001 /INITIALIZE POSTFIX CONVERSION OPERATOR HANDLING STACK, POINTERS TO STACKS AND /BUFFERS OPERATION SPECIFICATION FLAGS (i.e. "NEXT INPUT PROCESSED" AND /"OPERAND EXPECTED NEXT"). ETC. INTLZE, XX /INITIALIZATION ROUTINE TAD (POSTFX-1 /GET LOCATION ONE LESS THAN OPERATOR HANDLING STACK DCA POSTSP /SET STACK POINTER TO ONE LESS THAN START OF STACK DCA OPDNXT /SET "OPERAND EXPECTED NEXT" FLAG TO TRUE DCA NXTPRS /SET "NEXT INPUT PROCESSED" FLAG TO TRUE TAD (EQUAL /GET BOTTOM DELIMITER OF STACK JMS PSHSTK /PUSH IT ONTO OPERATOR HANDLING STACK TAD EQLVAL+1 /GET PRECEDENCE OF STACK DELIMITER JMS PSHSTK /PUSH IT ONTO OPERATOR HANDLING STACK JMP I INTLZE /RETURN TO CALLER /ROUTINE TO CHECK TO SEE IF THE STACK IS EMPTY EMPTY, XX /STACK EMPTY TEST ROUTINE TAD (POSTFX /GET BASE OF STACK CIA /GET NEGATIVE TAD POSTSP /ADD TO IT ADDRESS IN STACK POINTER SMA CLA /IS STACK EMPTY? ISZ EMPTY / NO: INCREMENT PC FOR NORMAL RETURN JMP I EMPTY / YES: RETURN TO END TRANSLATOR ROUTINE /THE FOLLOWING ROUTINE IS DONE WHILE THE STACK IS NOT EMPTY. IT TESTS FOR /INPUTS AND PROCESSING STATUS AND REQUESTS THE NEXT INPUT WHEN THE CONDITIONS /ARE MET. TSTINP, XX /TEST INPUT AND PROCESSING ROUTINE TAD NXTPRS /GET "NEXT INPUT PROCESSED" FLAG SZA CLA /IS NEXT INPUT PROCESSED YET? JMP DWNOUT / NO: THEN GO SET "NEXT INPUT PROCESSED" FLAG = FALSE JMS LEXIC / YES: GO GET NEXT INPUT TOKEN DCA TOKEN /SAVE TOKEN RETURNED IN AC TAD TOKEN /GET IT BACK SNA CLA /IS AN ERROR CONDITION PASSED BACK FROM SCANNER? JMP ERRTKN / YES: GO PROCESS SCANNER ERROR AND EXIT TRANSLATOR / NO: THEN TOKEN HAS TO BE AN OPERAND OR OPERATOR /SO GET FLAG & RETURN TO HANDLE EITHER OF THEM DWNOUT, AC7777 /GET A MINUS 1 TO SET "NEXT INPUT PROCESSED" FLAG DCA NXTPRS /SET "NEXT INPUT PROCESSED" = FALSE JMP I TSTINP /RETURN TO CALLER /THIS ROUTINE CHECKS TO SEE IF AN OPERAND IS EXPECTED. IF ONE IS THEN /IF THE TOKEN VALUE IN TOKEN (JUST PICKED UP FROM INPUT ROUTINE) /IS AN OPERAND IT IS OUTPUT TO THE POLISH STRING. IF NOT THEN IT CHECKS /FOR EITHER A LEFT PARENTHESIS OR UNARY MINUS, (IN THAT ORDER). /IF EITHER IS FOUND IT IS PUSHED ON TO THE OPERATOR STACK. IF NOT THEN /A "SYNTACTICAL ERROR" IS OUTPUT. APPROPRIATE FLAGS ARE SET ACCORDINGLY. /ELSE IF AN OPERAND IS NOT EXPECTED THEN GO PROCESS AS AN OPERATOR. /ROUTINE TO PROCESS OPERAND/OPERATOR OPERND, XX /OPERAND PROCESSING ROUTINE TAD OPDNXT /GET "OPERAND EXPECTED NEXT" FLAG SZA CLA /IS OPERAND EXPECTED NEXT? JMP OPRTOR / NO: THEN GO PROCESS AS OPERATOR / YES: THEN CHECK IF INPUT IS AN OPERAND VARIABLE TAD TOKEN /GET TOKEN PASSED FROM LEXIC TAD (-OPERAN /SET AC TO NEGATIVE VALUE OF OPERAND TOKEN SNA /IS IT AN OPERAND VARIABLE? JMP OUTOP / YES: OUTPUT TO POLISH STRING, RESET FLAGS,& RETURN / NO: CHECK TO SEE IF THE OPERAND IS A NUMBER TAD (OPERAN-NUMTOK /RESET AC & GET NEGATIVE VALUE OF NUMBER TOKEN /M043 SNA CLA /IS THE OPERAND A NUMBER? JMP OPDNUM / YES: OUTPUT TO POLISH STRING, RESET FLAGS,& RETURN / NO: CONTINUE BY CHECKING FOR "(" OR UNARY OPERATOR TAD LTPVAL /GET LEFT PARENTHESIS NEGATED ASCII VALUE INTO AC TAD TOKVAL /GET ASCII VALUE OF TOKEN PASSED SNA CLA /IS THE OPERATOR A LEFT PARENTHESIS? JMP LFTPUT / YES: GO TO ROUTINE TO PUT IT ON THE STACK TAD TOKVAL / NO: GET ASCII VALUE OF TOKEN PASSED TAD SUBVAL /GET NEGATED ASCII VALUE OF "-" SIGN SNA CLA /IS THE OPERATOR A UNARY MINUS? JMP OUTUNY / YES: GO PROCESS IT TAD TOKVAL / NO: GET ASCII VALUE OF TOKEN PASSED TAD ADDVAL /GET NEGATED ASCII VALUE OF "+" SIGN SNA CLA /IS THE OPERATOR A UNARY PLUS? /M016 JMP OUTUNY / YES: GO PROCESS IT /M016 /DO A CHECK HERE TO SEE IF USER PUT A HARD RETURN IN PLACE OF AN/A016 /OPERAND IN THE LEFT SIDE OF THE EQUATION. IF SO IT IS TRAPPED /A016 /OUT TO BE REPORTED BACK TO THE USER TO MAKE HIM AWARE OF THIS /A016 TAD TOKVAL / NO: GET ASCII VALUE OF TOKEN PASSED BACK /A016 TAD (-ECNWLN /GET NEGATIVE OF END OF LINE (HARD RETURN) /A016 SNA CLA /IS THE OPERATOR A HARD RETURN? /A016 JMP SYNR11 / YES: SYNTAX ERROR - FORMULA FORMAT INCORRECT /A016 /AT THIS POINT EVEN IF A HARD RETURN HAS NOT BEEN FOUND, AN /A016 /ERROR CONDITION HAS BEEN DISCOVERED BECAUSE EITHER AN OPERAND /A016 /OR ONE OF THE ABOVE CONDITIONS SHOULD HAVE BEEN MET AT THIS /A016 /POINT IN THE MATH EXPRESSION /A016 JMP SYNER1 / NO: SYNTAX ERR PROCESS "OPERAND NOT RECEIVED"/A016 / YES: CHECK IF ALREADY HAVE UNARY OPTR ON TOP OF STK /MULTIPLY SEQUENTIAL UNARY OPERATOR INPUT CHECK RTN OUTUNY, TAD UNYMNS+1 /GET PRECEDENCE OF UNARY OPERATOR CIA /SET UP FOR COMPARISON TAD I POSTSP /GET PRECEDENCE OFF TOP OF STACK SNA CLA /IS THERE ALREADY A UNARY OPERATOR ON TOP OF THE STK? JMP SYNER1 / YES: SYNTAX ERROR, PROCESS "OPERAND NOT RECEIVED" / NO: THEN PUT UNARY OPTR & IT'S PRECEDENCE ON STK /NOTE UNARY "+" & "-" BY ADDING 1000 TO THEIR VALUE TAD TOKVAL /GET INPUTTED UNARY OPERATOR TAD (1000 /ADD 1000 TO DISTINGUISH UNARY FROM REGULAR OPERATOR JMS PSHSTK /PUT IT ON THE STACK TAD UNYMNS+1 /GET UNARY OPERATOR PRECEDENCE JMS PSHSTK /PUT IT ON THE STACK JMP FLAGST /GO SET "NEXT INPUT PROCESSED" FLAG = TRUE & EXIT /ROUTINE TO PUT LEFT PARENTHESIS & IT'S PRECEDENCE ON STACK LFTPUT, TAD TOKVAL /GET LEFT PARENTHESIS ASCII VALUE JMS PSHSTK /PUT IT ON THE STACK TAD LTPVAL+1 /GET LEFT PARENTHESIS PRECEDENCE VALUE JMS PSHSTK /PUT IT ON THE STACK JMP FLAGST /GO SET "NEXT INPUT PROCESSED" FLAG=TRUE /THE FOLLOWING CODE SETS THE FLAGS ACCORDINGLY AND THAN EXITS /THE OPERAND/OPERATOR HANDLING ROUTINE FLGFIX, AC7777 /GET NEGATIVE VALUE AND DCA OPDNXT /SET "OPERAND EXPECTED NEXT" FLAG = FALSE FLAGST, CLA /GET ZERO VALUE AND DCA NXTPRS /SET "NEXT INPUT PROCESSED" FLAG = TRUE BACKUP, JMP I OPERND /RETURN TO CALLER (i.e. EXIT OPERAND/OPERATOR... /...PROCESSING ROUTINE "OPERND"). /D041 /SUBRTN PUTS INPUT OPERAND VARIABLE VALUE ADDRESS /D041 /& "PUSH" RTN ADDRESS INTO OUTPUT LIST /D041 PUTLST, XX /RTN PUTS INPUT OPRND VAR & "PUSH" RTN INTO OUTPUT LST /D041 TAD (PUSH /GET STARTING ADDRESS OF OUTPUT "PUSH" ROUTINE /D041 JMS OUTTSZ /SAVE IT, INCREMENT OUTPUT LST PTR & TEST FOR OVERFLOW /D041 TAD SYMPTR /GET ADDR OF VALUE OF INPUT OPERAND FROM SYM PTR TABLE /D041 JMS OUTTSZ /SAVE IT, INCREMENT OUTPUT LST PTR & TEST FOR OVERFLOW /D041 JMP I PUTLST /RETURN TO CALLER PSHLST, XX /PUT INPUT OPRND VAR & "PUSH" RTN INTO OUTPUT LST /A041 DCA TMPCTR /SAVE INPUT OPERAND VARIABLE /A041 TAD (PUSH /GET STARTING ADDRESS OF OUTPUT "PUSH" ROUTINE /A041 JMS OUTTSZ /SAVE IT, INC OUTPUT LST PTR & TEST FOR OVERFLOW /A041 TAD TMPCTR /GET INPUT OPERAND VARIABLE /A041 JMS OUTTSZ /SAVE IT, INC OUTPUT LST PTR & TEST FOR OVERFLOW /A041 JMP I PSHLST /RETURN TO CALLER /A041 X=. / INDICATE FIRST FREE LOCATION /A041 / ------------------ PAGE /THIS CROSS FIELD CALLABLE ROUTINE WILL DO A SYMBOL TABLE LOOKUP /ON THE WORD IN TOKVAL. / REGULAR RETURN IF SYMBOL NOT FOUND / SKIP RETURN IF IT IS FOUND / / CALLING CONVENTION: / CDFMYF / MAKE SURE DATA FIELD IS SET TO CALLING FIELD / CIFMTH / INSTRUCTION FIELD SET TO MATH FIELD / JMS SYMCHK / RETURN HERE IF NOT FOUND WITH AC=0 / RETURN HERE IF FOUND WITH AC= ADDRESS OF VALUE IN SYMTAB SYMCHK, XX GOTFLD /GO SET UP TO SAVE CALLING FIELD FOR RETURN /M041 DCA SYMOUT / PUT CIF CDF INSTRUCTION IN PLACE /D041 TAD (MTHTBL /GET SYM POINTER TABLE STARTING ADDRESS TAD (SYMTBL /GET POINTER TO SYMBOL TABLE STARTING ADDRESS /D041 DCA TMPTR2 /SAVE IT AS TEMP PTR TO SYM PTR TABLE DCA NMEPTR /SAVE AS POINTER TO NAME IN SYMBOL TABLE /A041 /GET SYM TBL NAME FOR COMPARISON WITH INPUT STRING OVRAGN, TAD TOKVAL /GET INPUT CHARACTER STRING SIZE CIA /SET UP COUNTER FOR END OF STRING MARKER DCA TMPCTR /SAVE IT TO COUNT CHARACTERS FOR INPUT STRING COMPARE /D041 TAD MTHPTR /GET PRESENT POSITION OF SYM PTR TABLE PTR /D041 CIA /GET IT'S NEGATIVE /D041 TAD TMPTR2 /GET TEMPORARY POINTER TO SYM PTR TABLE TAD NMEPTR /GET CURRENT POSITION INTO SYMBOL TABLE /A041 CIA /MAKE IT NEGATIVE /A041 TAD SYMPTR /SUBTRACT LAST ADDRESS OF SYMBOL TABLE /A041 SPA SNA CLA /HAVE ALL SYMBOLS BEEN TRIED FOR COMPARISON? /M041 JMP SYMOUT / YES: INPUT NOT IN SYM TABLE, DO REGULAR RETURN /D041 TAD I TMPTR2 / NO: GET ADDR TO VARIABLE NAME IN SYMBOL TABLE TAD NMEPTR / NO: GET ADDR TO VARIABLE NAME IN SYMBOL TABLE /A041 DCA SYMVAR /SAVE STARTING ADDRESS TO VARIABLE NAME IN SYMBOL TABLE TAD (TOKVAL+1 /GET BEGINNING ADDRESS OF INPUT STRING DCA TMPTR1 /SAVE IT AS POINTER TO INPUT TAD I NMEPTR /GET FIRST CHARACTER OF VARIABLE NAME /A041 TAD (200-": /CHECK FOR A COLON - ALL NAMES BEGIN WITH ONE /A041 SNA CLA /IF NOT THEN WE ARE POINTING TO A NUMBER CONSTANT /A041 JMP REPEAT /IT'S A NAME SO GO CHECK FOR A MATCH /A041 JMP VALSKP /IT'S A NUMBER SO GO MOVE THE POINTER OVER IT /A041 /MOVE POINTER TO NEXT ENTRY IN THE SYMBOL TABLE /A041 NXTSTR, TAD I NMEPTR /PICK UP A CHARACTER FROM THE SYMBOL TABLE /A041 ISZ NMEPTR /BUMP UP TO NEXT LOCATION /A041 SMA CLA /CHECK FOR THE END OF THE SYMBOL NAME /A041 JMP NXTSTR /NOT YET, GO CHECK AGAIN /A041 AC0001 /GOT IT, NOW ADD IN LENGTH OF FORMAT WORD /A041 VALSKP, TAD (VALSIZ /LENGTH OF A STORED NUMBER IN THE SYMBOL TABLE /A041 TAD NMEPTR /ADD TO PRESENT POINTER LOC INTO SYMBOL TABLE /A041 DCA NMEPTR /BUMP POINTER TO NEXT TABLE ENTRY /A041 JMP OVRAGN /GO CHECK THE NEXT TABLE ENTRY /A041 /COMPARE INPUT TO SYM TABLE STRING REPEAT, TAD I SYMVAR /GET CHARACTER FROM SYMBOL TABLE ISZ SYMVAR /INCREMENT SYM TABLE ADDR TO NEXT CHARACTER /A041 CIA /GET NEGATIVE OF ASCII VALUE OF CHARACTER TAD I TMPTR1 /GET CHARACTER FROM INPUT STRING ISZ TMPTR1 /INCREMENT INPUT STRING ADDR TO NEXT CHARACTER /A041 SZA CLA /DO THE CHARACTERS MATCH? JMP NXTSTR / NO: START COMPARISON WITH NEXT NAME IN SYM TABLE ISZ TMPCTR /ARE WE THRU WITH INPUT STRING? /D041 JMP CONTNU / NO: GO COMPARE NEXT SET OF CHARACTERS JMP REPEAT / NO: GO COMPARE NEXT SET OF CHARACTERS /M041 ISZ SYMCHK / YES: WE FOUND A MATCH SO DO A SKIP RETURN ISZ SYMVAR /INCREMENT POINTER PAST FORMAT WORD /A041 TAD SYMVAR /GET POINTER TO VALUE OF SYMBOL IN TABLE /A041 /(NEEDED BY WPSELC.PA WHO CALLS SYMCHK) /A003 SYMOUT, 0 / THIS GETS STUFFED WITH A CIF CDF TO CALLING FIELD JMP I SYMCHK / RETURN /D041 ISZ TMPTR2 /SET POINTER TO VALUE OF SYMBOL /D041 TAD I TMPTR2 / AND PUT ADDRESS OF SYMTAB ENTRY INTO AC /A003 /D041 / (NEEDED BY WPSELC.PA WHO CALLS SYMCHK) /A003 /D041 IAC / INCREMENT TO GET PAST FORMAT INDICATER /A005 /D041 JMP SYMOUT / /D041 CONTNU, ISZ SYMVAR /INCREMENT SYM TABLE ADDR TO NEXT CHARACTER /D041 ISZ TMPTR1 /INCREMENT INPUT STRING ADDR TO NEXT CHARACTER /D041 JMP REPEAT /GO COMPARE NEXT CHARACTER OF BOTH STRINGS /RETURN TO GET ANOTHER SYMBOL TABLE VARIABLE NAME /D041 NXTSTR, ISZ TMPTR2 /DOUBLE INCREMENT POINTER TO SYM PTR TABLE... /D041 ISZ TMPTR2 /...TO SKIP OVER ADDRESS OF VALUE OF VARIABLE /D041 JMP OVRAGN /GO BACK AND RUN COMPARE WITH ANOTHER SYM TABLE NAME /D041 SYMOUT, 0 / THIS GETS STUFFED WITH A CIF CDF TO CALLING FIELD /D041 JMP I SYMCHK / RETURN /TAKE OPERAND VARIABLE NAME AND IT'S VALUE ADDRESS AND PUSH IT /INTO POLISH FORMATTED OUTPUT LIST. BUT BEFORE OUTPUTTING OPERAND /CHECK FOR IT'S PRESENCE ALREADY IN THE SYMBOL TABLE. / CALL THE SYMCHK ROUTINE TO LOOK UP THE WORD IN TOKVAL (OPERAND / VARIABLE NAME) TO SEE IF IT IS ALREADY IN THE SYMBOL TABLE OUTOP, JMS SYMCHK / IS THE SYMBOL NAME ALREADY IN SYMBOL TABLE? JMP SYMADD / NO, GO ADD IT TO THE SYMBOL TABLE AC7777 /DON'T NEED POINTER TO NAME WHICH SYMCHK RETURNED/A041 TAD SYMVAR /GET POINTER TO ADDRESS OF FORMAT WORD IN TABLE /A041 DCA SVDFLC /SAVE POINTER IN CASE WE GET A FORMAT LATER /A041 TAD SYMVAR /GET POINTER TO VALUE OF SYMBOL IN TABLE /A041 JMS PSHLST /PUT IT ON THE STACK /A041 JMS CHKTYP /DO SPECIAL CHECK FOR EDITOR MATH /A041 JMP FLGFIX /GO SET FLAGS AND EXIT OPERAND/OPERATOR ROUTINE /A041 /THIS ROUTINE PROVIDES A HOOK TO PROCESS THE EDITOR MATH SYMBOLS /A041 /":Dnn" & ":Tnn", IF IN EDITOR MATH THEN GO PROCESS SYMBOLS BEING /A041 /PUT IN THE TABLE. IF SYMBOL IS ONE OF THE AFOREMENTIONED THEN IT IS /A041 /SAVED IN A SPECIAL TABLE TO BE USED BY THE EXTRACTION/INSERTION /A041 /ROUTINES IN EDITOR MATH /A041 CHKTYP, XX /HANDLE SPECIAL CHECK FOR EDITOR MATH /A041 TAD MTHTYP /GET "MATH MODE" FLAG /A041 SNA CLA /ARE WE IN LIST PROCESSING MATH? /A041 JMP I CHKTYP / YES: THEN RETURN TO CALLER /A041 TAD (NMEPTR / NO: GET POINTER TO START OF VARIABLE NAME /A041 CIFLP /CHANGE TO LP INSTRUCTION FIELD /A041 JMS CHKNME /GO PROCESS EDITOR MATH SYMBOL /A041 JMP I CHKTYP /RETURN TO CALLER /A041 /D041 /\JMP MATCH / YES, FALL INTO MATCH ROUTINE /D041 /OUTPUT ADDR OF VALUE OF OPERAND VARIABLE MATCHED IN SYM TBL /D041 /THIS RTN USED FOR INPUT VAR WITH MATCHUP FOUND IN SYM TBL /D041 MATCH, CLA /DON'T NEED POINTER TO NAME WHICH SYMCHK RETURNED/A003 /D041 TAD (PUSH /GET STARTING ADDRESS OF OUTPUT "PUSH" ROUTINE /D041 JMS OUTTSZ /SAVE IT, INCREMENT OUTPUT LST PTR & TEST FOR OVERFLOW /D041 TAD I TMPTR2 /GET PTR ADDR OF VALUE OF INPUT VARIABLE /A007 /D041 DCA SVDFLC / SAVE POINTER TO FORMAT INDICATOR INCASE WE GET/A007 /D041 / ONE LATER /A005 /D041 TAD I TMPTR2 /GET PTR ADDR OF VALUE OF INPUT VARIABLE /A007 /D041 IAC / INCREMENT TO GET PAST FORMAT INDICATER /A005 /D041 JMS OUTTSZ /SAVE IT, INCREMENT OUTPUT LST PTR & TEST FOR OVERFLOW /D041 /ROUTINE TO SAVE ADDR OF LAST OPERAND VARIABLE NAME AND /A001 /D041 /VALUE FOR LATER OUTPUT TO RESULT PTR TABLE IF REQUIRED. /A001 /D041 AC7777 /GET AC TO MINUS ONE /A001 /D041 TAD TMPTR2 /DECREMENT PTR TO SYMBOL POINTER TABLE /A001 /D041 DCA TMPTR2 /SAVE IT /A001 /D041 TAD I TMPTR2 /GET ADDR OF NAME OF INPUT OPERAND VARIABLE /A001 /D041 DCA NMEPTR /SAVE IT TO BE USED IN "RLTOUT" RTN /A001 /D041/HOOK HERE TO PROCESS EDITOR MATH SYMBOLS ":Dnn" & ":Tnn", IF IN /A030 /D041/EDITOR MATH THEN GO PROCESS SYMBOLS BEING PUT IN THE TABLE. IF /A030 /D041/SYMBOL IS ONE OF THE AFOREMENTIONED THEN IT IS SAVED IN A SPECIAL /A030 /D041/TABLE TO BE USED BY THE EXTRACTION/INSERTION ROUTINES IN EDITOR MATH/A030 /D041 TAD MTHTYP /GET "MATH MODE" FLAG /A030 /D041 SNA CLA /ARE WE IN LIST PROCESSING MATH? /A030 /D041 JMP MATCH1 / YES: THEN CONTINUE TO PROCESS IT /A030 /D041 TAD TMPTR2 / NO: GET PTR TO START OF MATCHED VAR NAME /A030 /D041 CIFLP /CHANGE TO LP INSTRUCTION FIELD /A030 /D041 JMS CHKNME /GO PROCESS EDITOR MATH SYMBOL /A030 /D041MATCH1, JMP FLGFIX /GO SET FLAGS AND EXIT OPERAND/OPERATOR ROUTINE /ADD INPUT VARIABLE NAME TO SYMBOL TABLE. THIS RTN USED FOR /INPUT OPERAND VARIABLES NOT FOUND IN SYMBOL TABLE SYMADD, TAD TOKVAL /GET LENGTH OF VARIABLE NAME CIA /SET UP NEGATIVE DCA TMPCTR /SAVE NEGATIVE AS A COUNTER /SAVE ADDR OF LAST INPUT OPERAND VARIABLE NAME FOR POSSIBLE /A001 /LATER OUTPUT TO RESULT PTR TBL BY "RLTOUT" RTN /A001 TAD SYMPTR /GET ADDRESS OF NAME OF INPUT OPERAND VARIABLE /A001 DCA NMEPTR /SAVE IT TO BE USED IN "RLTOUT" RTN /A001 /PUT INPUT OPERAND VARIABLE ADDRESS AND DEFAULT FORMAT /STATEMENT VALUE INTO SYMBOL POINTER TABLE /D041 TAD SYMPTR /GET FIRST FREE LOCATION IN SYMBOL TABLE /D041 DCA I MTHPTR /SAVE ADDR OF THIS LOCATION IN SYM PTR TABLE /D041 JMS MTHTSZ /INCREMENT PTR AND CHECK FOR SYM PTR TABLE OVERFLOW TAD (TOKVAL+1 /GET START OF INPUT STRING DCA TMPTR1 /SAVE IT AS A POINTER RETRY, TAD I TMPTR1 /GET A CHARACTER FROM THE INPUT STRING JMS SYMTSZ /OUTPUT TO SYMBOL TABLE & CHECK FOR OVERFLOW /M005 ISZ TMPTR1 /SET TOKVAL PTR TO NEXT INPUT CHARACTER ISZ TMPCTR /IS IT THE END OF THE INPUT STRING? JMP RETRY / NO: GO BACK AND GET ANOTHER CHARACTER / YES: PUT INPUT OPRND VAR ADDR INTO SYM PTR TBL /D041 /PUT INPUT OPERAND VALUE ADDRESS INTO SYMBOL POINTER TABLE /D041 TAD SYMPTR /GET BEGINNING ADDRESS OF FORMAT & VALUE /D041 DCA I MTHPTR /SAVE ADDRESS IN SYMBOL POINTER TABLE /D041 JMS MTHTSZ /INCREMENT PTR AND CHECK FOR SYM PTR TABLE OVERFLOW /PUT INPUT OPERAND VALUE DEFAULT FORMAT IN SYMBOL TABLE TAD SYMPTR /GET POINTER TO PLACE FOR FORMAT WORD /A007 DCA SVDFLC /AND SAVE FOR POSSIBLE USE IF FORMAT WORD FOUND /A007 TAD (DFAULT /GET DEFAULT VALUE FOR FORMAT JMS SYMTSZ /OUTPUT TO SYMBOL TABLE & CHECK FOR OVERFLOW /M005 TAD SYMPTR /GET POINTER TO PLACE FOR SYMBOL VALUE WORDS /A041 DCA SYMVAR /SAVE POINTER TO START OF SYMBOL VALUE /A041 JMS CHKTYP /DO SPECIAL CHECK FOR EDITOR MATH /A041 /PUT OPRND VAR VALUE ADDR & "PUSH" RTN ADDR INTO OUTPUT LST TAD SYMPTR /GET POINTER ADDRESS TO VALUE IN SYMBOL TABLE /A041 JMS PSHLST /PUSH VALUES ONTO OUTPUT LIST /A041 /D041/HOOK HERE TO PROCESS EDITOR MATH SYMBOLS ":Dnn" & ":Tnn", IF IN /A030 /D041/EDITOR MATH THEN GO PROCESS SYMBOLS BEING PUT IN THE TABLE. IF /A030 /D041/SYMBOL IS ONE OF THE AFOREMENTIONED THEN IT IS SAVED IN A SPECIAL /A030 /D041/TABLE TO BE USED BY THE EXTRACTION/INSERTION ROUTINES IN EDITOR MATH/A030 /D041 TAD MTHTYP /GET "MATH MODE" FLAG /D041 SNA CLA /ARE WE IN LIST PROCESSING MATH? /D041 JMP PRSCLP / YES: THEN CONTINUE TO PROCESS IT /D041 AC7776 /THEN SET AC TO POINT TO LATEST ENTRY IN /A023 /D041 TAD MTHPTR / SYMBOL TABLE /A023 /D041 CIFLP / NO: CHANGE INSTRUCTION REGISTER TO LP FIELD /D041 JMS CHKNME /GO PROCESS AS EDITOR MATH SYMBOL /D041 /PUT OPRND VAR VALUE ADDR & "PUSH" RTN ADDR INTO OUTPUT LST /D041 PRSCLP, JMS PUTLST /M020 /ALLOW "VALSIZ" LOCATIONS IN SYM TBL FOR VALUE OF INPUT OPERND /NOTE: FIRST LOC OF VALUE TO HOLD DEFAULT BIT SETTING OF NUM. /OTHER LOCATIONS OF VALUE TO BE INITIALIZED TO ZEROES. TAD (NMDFLT /GET INPUT OPERND VALUE DEFAULT BIT SETTING JMS SYMTSZ /OUTPUT TO SYMBOL TABLE & CHECK FOR OVERFLOW /M005 TAD (VALSIZ-1 /ADD FLOATING POINT VALUE SIZE -1 IN NUM OF LOCATIONS CIA /GET NEGATIVE DCA TMPCTR /SAVE IT TO USE AS A COUNTER VALOOP, JMS SYMTSZ /OUTPUT 0 TO SYMBOL TABLE & CHECK FOR OVERFLOW /M005 ISZ TMPCTR /DONE ALLOCATING SPACE IN SYM TBL FOR THE VALUE? JMP VALOOP / NO: MOVE SYM TBL PTR DOWN ANOTHER LOCATION JMP FLGFIX / YES: GO SET FLAGS AND EXIT OPERAND/OPERATOR ROUTINE /ROUTINE TO PROCESS NUMERICAL INPUT OPERAND OPDNUM, JMS CHKNUM /GO CHECK IF NUMBER IS ALREADY IN SYMBOL TABLE /A040 TAD SYMPTR /IT'S NOT, GET POINTER TO BOTTOM OF SYMBOL TABLE /A041 JMS PSHLST /GO PUT INPUT OPRND NUM & "PUSH" RTN INTO OUTPUT LST /PUT NUMERICAL INPUT OPERAND INTO SYMBOL TABLE TAD (TOKVAL /GET STARTING ADDR OF PASSED NUMERICAL OPERAND DCA TMPTR1 /SAVE IT FOR USE AS A POINTER TAD (VALSIZ /GET FLOATING POINT NUMBER SIZE CIA /GET NEGATIVE DCA TMPCTR /SET UP COUNTER OF NUMBER OF LOCATIONS CONTAINING NUM LOOPNM, TAD I TMPTR1 /GET ONE LOCATION'S WORTH OF NUMBER PASSED JMS SYMTSZ /OUTPUT TO SYMBOL TABLE & CHECK FOR OVERFLOW /M005 ISZ TMPTR1 /MOVE PTR TO NEXT LOCATION OF INPUT NUMBER /M040 ISZ TMPCTR /IS THE NUMBER DONE BEING TRANSFERRED YET? JMP LOOPNM / NO: GET NEXT PART OF INPUT NUMERICAL OPERAND /M040 JMP FLGFIX / YES: GO SET FLAGS & EXIT /MOVED HERE ON EDIT 041 /PROCESS TABLE USED IN RELATION TO CONTROL WORD FOUND IN CONTROL BLOCK. THE /CONTROL WORD MATCHED UP IN THE SYMBOL TABLE IS GIVEN A NUMBER WHICH, WHEN /RETURNED IN THE AC, IS USED AS AN OFFSET TO JUMP INTO THE RELATED RTN HERE HNDCTL, BEGIN /ADDRESS OF "BEGIN" PROCESSING ROUTINE /A018 END / " " "END" " " /A018 TOTAL / " " "TOTAL" " " /A018 FRMULA / " " "FORMULA" " " ROUND / " " "ROUND" " " TRNCTE / " " "TRUNCATE" " " SETCMD / " " "SET" " " /M042 X=. / INDICATE FIRST FREE LOCATION /A041 / ------------------ PAGE /ROUTINE TO HANDLE INPUTED OPERATOR TOKEN, IT'S VALUE, AND PRECEDENCE /AS COMPARED TO WHAT IS PRESENTLY ON THE STACK. /NOTE: A BRANCH IS DONE TO HERE IF THE BEGINNING OF "OPERAND" ROUTINE IS NOT /AN OPERAND EXPECTED OR ONE OF SEVERAL SPECIAL CASES HANDLED THERE. ASCPTR, 0 /POINTER TO OPERATOR ASCII VALUE TABLE - KEEP ON SAME /PAGE AS "OPRTOR" ROUTINE TMPOPR, 0 /USED TO SAVE VALUE OF INPUT OPERATOR, KEEP ON SAME /PAGE AS "SKPDWN", "TYPOPR", AND "POPOUT" ROUTINES /CHECK TO SEE IF THE TOKEN PASSED IS AN OPERATOR OPRTOR, TAD (-OPERAT /SET AC TO NEGATIVE OF OPERATOR TOKEN TAD TOKEN /ADD TOKEN PASSED FROM LEXIC SZA CLA /IS THE TOKEN PASSED AN OPERATOR? JMP SYNER2 / NO: OUTPUT SYNTAX ERROR "OPERATOR NOT RECEIVED" / YES: CHECK FOR "END OF LINE" RETURNED /A008 TAD TOKVAL /GET VALUE PASSED FROM LEXIC /A008 TAD (-ECNWLN /ADD TO IT "END OF LINE" (I.E HARD RETURN) /A008 SNA CLA /IS OPERATOR PASSED BACK AN "END OF LINE"? /A008 JMP SYNR11 / YES: SYNTAX ERROR - FORMULA FORMAT INCORRECT /A008 /NOTE: ERROR "SYNR11" NOW INFORMS USER AS TO /A016 /ILLEGAL PLACEMENT OF A HARD RETURN WITHIN THE /A016 /CONTEXT OF A MATH EXPRESSION. THIS IS ONE OF /A016 /PLACES WHERE IT GETS TRAPPED OUT TO DO THIS /A016 / NO: CHECK FOR TYPE OF OPERATOR SKPDWN, TAD TOKVAL /GET VALUE OF INPUT OPERATOR FROM TOKVAL DCA TMPOPR /SAVE IT IN LOCATION WHERE CAN BE HANDLED BY "TYPOPR" JMS TYPOPR /GO FIND OUT WHICH TYPE OF OPERATOR HAS BEEN INPUT JMP FOUND /GO HANDLE OPERATOR MATCHUP FOUND /SUBROUTINE TO CHECK FOR TYPE OF OPERATOR INPUTTED /NOTE: THIS ROUTINE LEAVES THE OPERATOR NEGATIVE ASCII VALUE /TABLE POINTER POINTED TO THE NEGATIVE ASCII OPERATOR VALUE /THAT MATCHES THE INPUTTED OPERATOR! IT IS USED AS A REFERENCE /POINT FROM WHICH TO GET THE OPERATOR PRECEDENCE FOR STACK /MANIPULATIONS AND THE OPERATOR FUNCTION ROUTINE ADDRESS /WHICH MUST BE PLACED INTO THE OUTPUT LIST TYPOPR, XX /SUBROUTINE TO FIND OPERATOR MATCH IN TABLE TAD (ADDVAL /GET THE START OF OPERATOR ASCII VALUES TABLE DCA ASCPTR /SAVE IT TO USE AS POINTER BGNLOP, TAD I ASCPTR /GET NEGATIVE OF ASCII VALUE OF OPERATOR FROM TABLE TAD TMPOPR /GET ASCII VALUE OF INPUT OPERATOR TO BE FOUND SNA CLA /IS NEGATIVE ASCII VALUE OF OPERATOR FOUND? JMP I TYPOPR / YES: RETURN TO CALLER WITH PTR SET AT MATCH FOUND ISZ ASCPTR / NO: SET POINTER TO NEXT VALUE ISZ ASCPTR /DOUBLE INCREMENTED TO BYPASS PRECEDENCE IN TABLE ISZ ASCPTR /TRIPLE " TO BYPASS OPTR FUNCTION RTN ADDR IN TBL JMP BGNLOP /AND TRY AGAIN TO FIND RIGHT ASCII VALUE /RTN TO HANDLE THE TYPE OF OPERATOR FOUND BY DOING PRECEDENCE /COMPARISON OF OPERATOR ON TOP OF STACK WITH INPUT OPERATOR. FOUND, ISZ ASCPTR /MOVE TOKEN TBLE PTR TO PRECEDENCE OF OPERATOR FOUND TAD I ASCPTR /GET PRECEDENCE OF INPUT OPERATOR CIA /GET NEGATIVE TAD I POSTSP /GET PRECEDENCE OFF TOP OF OPERATOR STACK SNA /DOES THE PRECEDENCE OF NEXT INPUT=TOP OF STACK? JMP EQUALP / YES: GO HANDLE CASE OF EQUAL PRECEDENCE SPA CLA / NO: IS PRECEDENCE OF INPUT LESS THAN TOP OF STK? JMP HIGHRP / NO: THAN GO HANDLE CASE OF HIGHER PRECEDENCE / YES: THAN HANDLE CASE OF LOWER PRECEDENCE HERE /CASE OF PRECEDENCE OF NEXT INPUT IS LESS THAN THAT OF TOP OF STACK LOWERP, JMS TOPOPR /GET ASCII VALUE OF TOP OPERATOR OF STACK INTO AC TAD LTPVAL /ADD TO IT NEGATIVE ASCII VALUE OF "(" OPERATOR SNA CLA /IS THERE A LEFT PARENTHESIS ON THE TOP OF THE STACK? JMP SYNER3 / YES: SYNTAX ERROR "TOO MANY LEFT PARENTHESIS" JMS POPOUT / NO: THEN POP STACK AND OUTPUT TO POLISH STRING JMP BACKUP /GO EXIT OPERAND/OPERATOR PROCESSING ROUTINE /CASE OF PRECEDENCE OF NEXT INPUT IS EQUAL THAT OF TOP OF STACK EQUALP, JMS TOPOPR /GET ASCII VALUE OF TOP OPERATOR OF STACK INTO AC TAD LTPVAL /ADD TO IT NEGATIVE ASCII VALUE OF "(" OPERATOR SNA CLA /IS THERE A LEFT PARENTHESIS ON THE TOP OF THE STACK? JMP SVCLTP / YES: THEN GO PROCESS IT JMS POPOUT / NO: POP STACK AND PUT IN OUTPUT LIST JMP BACKUP /GO EXIT OPERAND/OPERATOR PROCESSING ROUTINE /EQUAL PRECEDENCE AND "(" ON TOP OF THE STACK SVCLTP, JMS FLSHST /GO CLEAR THE TOP OPERATOR & IT'S PRECEDENCE OFF STACK JMP FLAGST /GO SET "NEXT INPUT PROCESSED" FLAG=TRUE AND THEN EXIT /CASE OF PRECEDENCE OF NEXT INPUT IS GREATER THAN THAT OF TOP OF STACK HIGHRP, TAD TOKVAL /GET ASCII VALUE OF INPUT OPERATOR TAD RTPVAL /GET NEGATIVE ASCII VALUE OF RIGHT PARENTHESIS SNA CLA /IS NEXT INPUT A RIGHT PARENTHESIS? JMP SYNER4 / YES:PROCESS SYNTAX ERROR "TO MANY RIGHT PARENTHESIS TAD TOKVAL / NO: GET INPUT OPERATOR... JMS PSHSTK /...AND PUSH IT INTO THE STACK TAD I ASCPTR /GET INPUT OPERATOR PRECEDENCE (PTR SET IN 'FOUND'RTN) JMS PSHSTK /...AND PUSH IT INTO STACK DCA OPDNXT /SET "OPERAND EXPECTED NEXT" FLAG=TRUE JMP FLAGST /SET "NEXT INPUT PROCESSED" FLAG=TRUE AND EXIT /SUBROUTINES USED BY THE PREVIOUS OPERATOR PROCESSING CODE /THIS ROUTINE POPS THE TOP OPERATOR OFF THE STACK AND /OUTPUTS THE ADDRESS OF THE FUNCTION ROUTINE THAT /COINCIDES WITH THAT OPERATOR TO THE OUTPUT LIST. IT ALSO /ELIMINATES UNARY PLUS OPERATORS FROM BEING OUTPUT TO THE LIST POPOUT, XX /POP STACK & OUTPUT TO POLISH STRING ROUTINE JMS POPSTK /CLEAR PRECEDENCE OFF TOP OF STACK... JMS POPSTK /...AND GET TOP OPERATOR OFF OF STACK DCA TMPOPR /SAVE IT IN LOCATION TO HANDLE MATCHUP WITH TABLE JMS TYPOPR /GET POINTER TO MATCHING OPERATOR IN OPR VALUE TBL ISZ ASCPTR /DOUBLE INCREMENT POINTER TO LINE UP ON MATCHING... ISZ ASCPTR /...ROUTINE THAT PERFORMS OPERATOR FUNCTION TAD I ASCPTR /GET ADDRESS OF THAT OPERATOR FUNCTION ROUTINE SNA /IS THE TOP OPERATOR ON THE STACK A UNARY PLUS JMP I POPOUT / YES: THEN DUMP IT AND RETURN JMS OUTTSZ / NO: SAVE IT, INCREMENT O/P LST PTR & TEST FOR OVFLW JMP I POPOUT /RETURN TO CALLER /THIS ROUTINE RETURNS TO A CALLER THE ASCII VALUE OF THE TOP /OPERATOR IN THE OPERATOR STACK. IT'S ASCII VALUE IS RETURNED /TO THE CALLER IN THE AC TOPOPR, XX /GET TOP OPERATOR FROM STACK ROUTINE AC7777 /SET AC TO -1 TAD POSTSP /DECREMENT STACK POINTER 1 LOCATION TO REACH OPERATOR DCA TMPTR2 /SAVE IT TAD I TMPTR2 /GET TOP OPERATOR OFF OF STACK JMP I TOPOPR /RETURN TO CALLER WITH OPERATOR ASCII VALUE IN AC /SUBROUTINE CALLED FROM "RTRN4A" TO INITIALIZE PATCHES TO THE "PRCTRL" /A019 /ROUTINE. THIS IS DONE TO ALLOW FOR DIFFERENT ENTRY POINTS INTO THE /A019 /PERMENANT SYMBOL TABLE WHERE CTRL WORDS ARE EVALUATED FOR PROCESSING /A019 /THE CODE ENTERS AT "EDTCTL" FOR EDIT MATH & "CTLWRD" FOR LP MATH /A019 SETCTL, XX TAD MTHTYP /GET THE MATH MODE FLAG /A019 SNA CLA /IS IT EDITOR MATH THAT'S WANTED? /A019 TAD (3 / NO: GET THE OFFSET IF LP MATH /A019 DCA OFFSET / YES: PATCH IT TO USE IN MATH PROCESSING /A019 TAD MTHTYP /GET THE MATH MODE FLAG BACK /A019 SZA CLA /IS IT LP MATH THAT'S WANTED? /A019 TAD (EDTCTL-CTLWRD / NO: SET SYM TBL ENTRY FOR EDITOR MATH /A019 TAD (CTLWRD / YES: " " " " " LP " /A019 DCA SYMSTR /PATCH IT TO USE IN MATH PROCESSING /A019 TAD MTHTYP /GET THE MATH MODE FLAG /A019 SNA /IS IT EDIT MATH THAT IS WANTED? /A019 JMP I SETCTL / NO: JUST RETURN TO CALLER /A019 CDFLP / YES: SET DATA FIELD TO LP /A019 DCA I (INCTLB /INIT "IN CONTROL BLOCK" FLAG TO FALSE /A019 CDFMYF /RESET DATA FIELD TO MATH /A019 AC0001 /GET 1 IN THE AC /A020 DCA MTHWRK /SET "IN MATH WORK AREA" = FALSE /A020 AC0001 /GET 1 IN THE AC /A020 DCA MTHSND /SET "PROCESSING SECOND LINE" = FALSE /A020 DCA MTHTOT /SET "MATH TOTAL REQUIRED" = FALSE /A020 CIFLP /CHANGE PROGRAM CONTROL TO LP FIELD /M029 JMS ZROTBL /GO INIT "DCHAR" & "TCHAR" TABLES /A020 JMP I SETCTL /RETURN TO CALLER /A019 /MOVED HERE ON EDIT 041 /ROUTINE TO MAKE CDI INSTRUCTION TO CALLING FIELD AND PUT IN AC /A006 GETFLD, XX /A006 CLA /CLEAR AC /A006 RDF /GET DATA FIELD BITS FROM WHICH CALL WAS MADE /A006 TAD CIDF0 /ADD TO IT THE CDF,CIF OCTAL CODE VALUE /A006 CDFMTH /CHANGE THE DATA FIELD REGISTER TO MATH FIELD /A006 JMP I GETFLD /RETURN TO CALLER ON THIS PAGE /A006 X=. / INDICATE FIRST FREE LOCATION /A041 / ------------------ PAGE /PERMANENT SYMBOL TABLES - CONTAINS THE CONTROL WORDS WHICH MAY BE A PART /OF THE LIST PROCESSING AND/OR EDITOR MATH CONTROL BLOCK. /USED TO ANALYZE THE CONTENTS OF THE MATH CONTROL BLOCK IN LP & EDITOR MATH WPSMTH, IFDEF ENGLSH< /A045 "W-200 / W "P-200 / P "S-200 / S "M-200 / M "A-200 / A "T-200 / T "H-200+4000 / H+4000 > /A045 /A045 IFDEF DUTCH< /A047 "R-200 / W "E-200 / P "K-200 / S "E-200 / M "N-200 / A "E-200 / T "N-200+4000 / H+4000 > /A047 /A047 IFDEF ITALIAN< /A045 "W-200 / W /A045 "P-200 / P /A045 "S-200 / S /A045 "M-200 / M /A045 "A-200 / A /A045 "T-200+4000 / T+4000 /A045 > /A045 IFDEF SPANISH< /A046 "W-200 / W /A046 "P-200 / P /A046 "S-200 / S /A046 "M-200 / M /A046 "A-200 / A /A046 "T-200+4000 / T+4000 /A046 > /A046 IFDEF V30NOR< /A047 "R-200 / R /A047 "E-200 / E /A047 "G-200 / G /A047 "N-200 / N /A047 "I-200 / I /A047 "N-200 / N /A047 "G-200+4000 / G+4000 /A047 > /A047 IFDEF V30SWE< /A047 "W-200 / W /A047 "P-200 / P /A047 "S-200 / S /A047 "M-200 / M /A047 "A-200 / A /A047 "T-200+4000 / T+4000 /A047 / THE LAST BIT LOPPED OFF AS IT OVERFLOWS THE WRKBUF IN MATH. /A047 /D047 "E-200 / E /A047 / " "M-200 / M /A047 / " "A-200 / A /A047 / " "T-200 / T /A047 / " "I-200 / I /A047 /D047 "K-200+4000 / K+4000 /A047 > /A047 0 / NULL = END OF SYMBOL TABLE /START OF EDITOR MATH CONTROL BLOCK CONTROL WORDS /A005 EDTCTL, IFDEF ENGLSH< /a045 "B-200 / B /A005 "E-200 / E /A005 "G-200 / G /A005 "I-200 / I /A005 "N-200+4000 / N+4000 /A005 > /A045 IFDEF DUTCH< /a047 "B-200 / B /A047 "E-200 / E /A047 "G-200 / G /A047 "I-200 / I /A047 "N-200+4000 / N+4000 /A047 > /A047 IFDEF ITALIAN< /a045 "I-200 / I /A045 "N-200 / N /A045 "I-200 / I /A045 "Z-200 / Z /A045 "I-200 / I /A045 "O-200+4000 / O+4000 /A045 > /A045 IFDEF SPANISH< /a046 "E-200 / E /A046 "M-200 / M /A046 "P-200 / P /A046 "E-200 / E /A046 "Z-200 / Z /A046 "A-200 / A /A046 "R-200+4000 / R+4000 /A046 > /A046 IFDEF V30NOR< /a047 "B-200 / B /A047 "E-200 / E /A047 "G-200 / G /A047 "Y-200 / Y /A047 "N-200 / N /A047 "N-200+4000 / N+4000 /A047 > /A047 IFDEF V30SWE< /a047 "B-200 / B /A047 "V-200 / V /A047 "R-200 / R /A047 "J-200 / J /A047 "A-200+4000 / A+4000 /A047 > /A047 IFDEF ENGLSH< /A045 "E-200 / E /A005 "N-200 / N /A005 "D-200+4000 / D+4000 /A005 > /A045 IFDEF DUTCH< /A047 "E-200 / E /A047 "I-200 / E /A047 "N-200 / E /A047 "D-200 / N /A047 "E-200+4000 / D+4000 /A047 > /A047 IFDEF ITALIAN< /A045 "F-200 / F /A045 "I-200 / I /A045 "N-200 / N /A045 "E-200+4000 / E+4000 /A045 > /A045 IFDEF SPANISH< /A046 "F-200 / F /A046 "I-200 / I /A046 "N-200+4000 / N+4000 /A046 > /A046 IFDEF V30NOR< /A047 "S-200 / S /A047 "L-200 / L /A047 "U-200 / U /A047 "T-200 / T /A047 "T-200+4000 / T+4000 /A047 > /A047 IFDEF V30SWE< /A047 "S-200 / S /A047 "L-200 / L /A047 "U-200 / U /A047 "T-200+4000 / T+4000 /A047 > /A047 IFDEF ENGLSH< /A045 "T-200 / T /A005 "O-200 / O /A005 "T-200 / T /A005 "A-200 / A /A005 "L-200+4000 / L+4OOO /A005 > IFDEF DUTCH< /A047 "T-200 / T /A047 "O-200 / O /A047 "T-200 / T /A047 "A-200 / A /A047 "A-200 / A /A047 "L-200+4000 / L+4OOO /A047 > IFDEF ITALIAN< /a045 "T-200 / T /A045 "O-200 / O /A045 "T-200 / T /A045 "A-200 / A /A045 "L-200 / L /A045 "E-200+4000 / E+4000 /A045 > /A045 IFDEF SPANISH< /a046 "T-200 / T /A046 "O-200 / O /A046 "T-200 / T /A046 "A-200 / A /A046 "L-200+4000 / L+4000 /A046 > /A046 IFDEF V30NOR< /a047 "S-200 / S /A047 "U-200 / U /A047 "M-200+4000 / M+4000 /A047 > /A047 IFDEF V30SWE< /a047 "T-200 / T /A047 "O-200 / O /A047 "T-200 / T /A047 "A-200 / A /A047 "L-200 / L /A047 "T-200+4000 / T+4000 /A047 > /A047 /START OF LP MATH CONTROL BLOCK CONTROL WORDS CTLWRD, IFDEF ENGLSH< /A045 "F-200 / F "O-200 / O "R-200 / R "M-200 / M "U-200 / U "L-200 / L "A-200+4000 / A+4000 > /A045 IFDEF DUTCH< /A047 "F-200 / F "O-200 / O "R-200 / R "M-200 / M "U-200 / U "L-200 / L "E-200+4000 / A+4000 > /A047 IFDEF ITALIAN< /A045 "F-200 / F /A045 "O-200 / O /A045 "R-200 / R /A045 "M-200 / M /A045 "U-200 / U /A045 "L-200 / L /A045 "A-200+4000 / A+4000 /A045 > /A045 IFDEF SPANISH< /A046 "F-200 / F /A046 "O-200 / O /A046 "R-200 / R /A046 "M-200 / M /A046 "U-200 / U /A046 "L-200 / L /A046 "A-200+4000 / A+4000 /A046 > /A046 IFDEF V30NOR< /A047 "F-200 / F /A047 "O-200 / O /A047 "R-200 / R /A047 "M-200 / M /A047 "E-200 / E /A047 "L-200+4000 / L+4000 /A047 > /A047 IFDEF V30SWE< /A047 "F-200 / F /A047 "O-200 / O /A047 "R-200 / R /A047 "M-200 / M /A047 "E-200 / E /A047 "L-200+4000 / L+4000 /A047 > /A047 IFDEF ENGLSH< /A045 "R-200 / R "O-200 / O "U-200 / U "N-200 / N "D-200+4000 / D+4000 > IFDEF DUTCH< /A047 "A-200 / R "F-200 / R "R-200 / R "O-200 / O "N-200 / N "D-200 / N "E-200 / N "N-200+4000 / D+4000 > IFDEF ITALIAN< /A045 "A-200 / A /A045 "R-200 / R /A045 "R-200 / R /A045 "O-200 / O /A045 "T-200 / T /A045 "O-200 / O /A045 "N-200 / N /A045 "D-200 / D /A045 "A-200+4000 / A+4000 /A045 > /A045 IFDEF SPANISH< /A046 "R-200 / R /A046 "E-200 / E /A046 "D-200 / D /A046 "O-200 / O /A046 "N-200 / N /A046 "D-200 / D /A046 "E-200 / E /A046 "A-200 / A /A046 "R-200+4000 / R+4000 /A046 > /A046 IFDEF V30NOR< /A047 "A-200 / A /A047 "V-200 / V /A047 "R-200 / R /A047 "U-200 / U /A047 "N-200 / N /A047 "D-200+4000 / D+4000 /A047 > /A047 IFDEF V30SWE< /A047 "R-200 / R /A047 "U-200 / U /A047 "N-200 / N /A047 "T-200+4000 / T+4000 /A047 > /A047 IFDEF ENGLSH< /A045 "T-200 / T "R-200 / R "U-200 / U "N-200 / N "C-200 / C "A-200 / A "T-200 / T "E-200+4000 / E+4000 > /A045 IFDEF DUTCH< /A047 "K-200 / T "A-200 / R "P-200+4000 / E+4000 > /A047 IFDEF ITALIAN< /A045 "T-200 / T /A045 "R-200 / R /A045 "O-200 / O /A045 "N-200 / N /A045 "C-200 / C /A045 "A-200+4000 / A+4000 /A045 > /A045 IFDEF SPANISH< /A046 "T-200 / T /A046 "R-200 / R /A046 "U-200 / U /A046 "N-200 / N /A046 "C-200 / C /A046 "A-200 / A /A046 "R-200+4000 / R+4000 /A046 > /A046 IFDEF V30NOR< /A047 "K-200 / K /A047 "U-200 / U /A047 "T-200 / T /A047 "T-200+4000 / T+4000 /A047 > /A047 IFDEF V30SWE< /A047 "T-200 / T /A047 "R-200 / R /A047 "U-200 / U /A047 "N-200 / N /A047 "K-200 / K /A047 "E-200 / E /A047 "R-200 / R /A047 "A-200+4000 / A+4000 /A047 > /A047 IFDEF ENGLSH< /A045 "S-200 / S "E-200 / E "T-200+4000 / T+4000 > /A045 IFDEF DUTCH< /A047 "S-200 / S "T-200 / E "E-200 / E "L-200+4000 / T+4000 > /A047 IFDEF ITALIAN< /A045 "P-200 / P /A045 "O-200 / O /A045 "N-200 / N /A045 "I-200+4000 / I+4000 /A045 > /A045 IFDEF SPANISH< /A046 "P-200 / P /A046 "O-200 / O /A046 "N-200 / N /A046 "E-200 / E /A046 "R-200+4000 / R+4000 /A046 > /A046 IFDEF V30NOR< /A047 "S-200 / S /A047 "E-200 / E /A047 "T-200 / T /A047 "T-200+4000 / T+4000 /A047 > /A047 IFDEF V30SWE< /A047 "S-200 / S /A047 "T-200 / T /A047 "O-200 / O /A047 "L-200 / L /A047 "L-200 / L /A047 "_-200 / (underline) /A047 "I-200 / I /A047 "N-200+4000 / N+4000 /A047 > /A047 0 / NULL = END OF SYMBOL TABLE /THIS TABLE HOLDS NEGATIVE ASCII VALUES OF OPTRS FOR MATCHUP WHENEVER AN OPTR /TKN IS PASSED TO "XLTFRM" (TRANSLATOR) FROM LEXIC (SCANNER) VIA TOKVAL. /THE TBL INCLUDES PRECEDENCE OF OPTR TYPE, & ADDR OF EXECUTION ROUTINE THAT /WILL PERFORM (ON THE OUTPUT LIST) REQUIRED FUNCTIONALITY OF THAT OPERATOR. ADDVAL, -"++200;4;ADD /TWO'S COMPLIMENT OF ADDITION OPERATOR /PLUS PRECEDENCE /PLUS ADDRESS OF ROUTINE EXECUTING THIS FUNCTION SUBVAL, -"-+200;4;SUB / " " " SUBTRACTION OPERATOR / " " " / " " " MLTVAL, -"*+200;5;MUL / " " " MULTIPLICATION OPERATOR / " " " / " " " DIVVAL, -"/+200;5;DIV / " " " DIVISION OPERATOR / " " " / " " " EQLVAL, -"=+200;1;EQUATE / " " " EQUALS (OR ASSIGN) OPERATOR / " " " / " " " LTPVAL, -"(+200;2;0000 / " " " LEFT PARENTHESIS OPERATOR / " " " / PLACE ZERO HERE AS FILLER - NO LEFT PAREN RTN RTPVAL, -")+200;2;0000 / " " " RIGHT PARENTHESIS OPERATOR / " " " / PLACE ZERO HERE AS FILLER - NO RIGHT PAREN RTN UNYMNS, -"-+7000+200;6;MINUS/ " " " UNARY MINUS OPERATOR / " " " / " " " UNYPLS, -"++7000+200;6;0000 / " " " UNARY PLUS OPERATOR / " " " / " " " /"RUNCHK" IS CALLED FROM "RTRN3A". IT DETERMINES IF IN EDIT MATH, IF IN /A010 /EDITOR MATH WORK AREA, AND ACTS ACCORDINGLY. THIS RTN IS A KIND OF /A010 /CRUNCH JOB BECAUSE OF LACK OF SPACE AND TO SAVE ON EXECUTION TIME /A010 /WHILE IN THE EDITOR. RUNCHK, XX /A010 TAD MTHTYP /GET "MATH MODE" FLAG /A010 SNA CLA /ARE WE IN EDIT MATH MODE? /A010 JMP I RUNCHK / NO: JUST RETURN TO PROCESS CTRL WORD /A010 TAD MTHWRK / YES: GET "EDIT MATH WORK AREA" FLAG /A010 SNA CLA /ARE WE IN EDIT MATH WORK AREA? /M031 JMP I RUNCHK / YES: RETURN TO PROCESS CTRL WORD /A010 CDFLP / NO: CHANGE TO LP DATA FIELD /A010 AC0001 /GET 1 IN THE AC /A035 DCA MTHSND /SET "NOT MATH CTRL BLOCK SECOND LINE" = TRUE /A035 /TAKE TIME HERE TO MAKE SURE THAT THE 2ND LINE /A035 /FLAG IS SET TO SAY NOT PROCESSING THAT LINE /A035 /ANYMORE. DONE IN CASE 1ST WORD IN BLOCK WAS /A035 /"WPSMATH" & 2ND WORD (WHICH ENDS UP HERE IF /A035 /A VALID COMMAND BUT NOT "BEGIN") HAS CLEARED /A035 /THE FLAG TO SAY PROCESSING SECOND LINE /A035 /D031 DCA I (INCTLB /SET "IN CONTROL BLOCK" FLAG = FALSE /A010 DCA I (MTHCTL /SET "IN MATH CTRL BLOCK" FLAG = FALSE /A031 /D035 TAD I (CKCTRL /GET "CKCTRL" RTRN ADDR BACK TO EDIT CODE /A010 /D035 DCA RUNCHK /SET IT UP TO RTRN THRU BACK TO THE EDITOR /A010 CDILP /CHANGE PROGRAM CONTROL BACK TO LP FIELD /A010 /D035 JMP I RUNCHK /RETURN TO EDIT CODE /A010 JMP RTNMTH /THERE WAS A MAJOR BUG HERE SINCE THE CODE /A035 /CHANGE TO REFLECT SAVING AND RESTORING "CURPTR"/A035 /IN "CKCTRL" AND "EXTRACTNUMBER" FOR EDITOR MATH/A035 /ALLOWED A JMP INDIRECT THRU "RUNCHK" BACK /A035 /TO THE EDITOR TO NOW, AMONG OTHER THINGS, BLOW /A035 /THE LINE AFTER THE BLOCK RIGHT OUT OF THE WATER/A035 /UNDER THE RIGHT CONDITIONS BECAUSE A CALL WAS /A035 /NOT ADDED TO RESET "CURPTR" HERE WHEN THE CODE /A035 /WAS CHANGED EVERYWHERE ELSE! THIS FIX /A035 /TAKES THE ABOVE INTO ACCOUNT. /A035 /POPSTK, MOVED TO LEXASC TO CREATE ENOUGH ROOM FOR THE ITALIAN /A045 /TRANSLATIONS ABOVE. /A045 /SYMTSZ, MOVED TO ANOTHER PAGE FOR SPACE REASONS /D041 /D041 /SUBRTN TO INIT RESULT PTR TBL PTR, & 1ST LOC OF RES PTR TBL /M012 /D041 ITLZOL, XX /RESULT PTR TBL & RESULTS PTR INIT SUB RTN /M012 /D041 CLA /CLEAR AC /D041 TAD (RESULT /GET STARTING ADDRESS OF RESULT PTR TABLE /D041 DCA RESPTR /INITIALIZE PTR TO RESULT PTR TABLE /D041 DCA I RESPTR /INIT 1ST LOC OF RESULT PTR TABLE TO ZERO /D041 JMP I ITLZOL /RETURN TO CALLER /A012 /D041 /SUBRTN USED TO INSTALL SETUP VALUES IN BEGINNING LOCATIONS OF OUTPUT /D041 /LIST TO ENABLE OUTPUT LIST TO BE USED BY FORMULA EXECUTION CODE AS A /D041 /CALLABLE ROUTINE. /D041 ITLZO1, XX /PUT VALUES IN OUTPUT LIST /D041 TAD (INIT /GET JMP INDIRECT COMMAND TO HANDLE OUTPUT LIST /A004 /D041 JMS OUTTSZ /SAVE IT, INCREMENT PTR & TEST FOR OVERFLOW /A004 /D041 /PLACE "(JMP I OUTEXT" AT END OF OUTPUT LIST TO EXECUTE AS A ROUTINE /D041 TAD (JMP I OUTEXT /GET JMP I OUTEXT /D041 DCA I OUTPTR /PUT AT END OF OUTPUT LIST FOR USE BY EXECUTION CODE. /D041 JMP I ITLZO1 /RETURN TO CALLER /D041/SUBRTNS TO PERFORM TRANSLATOR INITIALIZATION PROCESS & /D041/INITIALIZE APPROPRIATE FLAGS /D041 ITLZO2, XX /TRANSLATOR INITIALIZATION SUBROUTINE /M012 /D041 TAD (MTHTBL /GET STARTING ADDRESS OF SYMBOL PTR TABLE /D041 DCA MTHPTR /INITIALIZE PTR TO SYMBOL PTR TABLE /D041 TAD (SYMTBL /GET STARTING ADDRESS OF SYMBOL TABLE /D041 DCA SYMPTR /INITIALIZE PTR TO SYMBOL TABLE /D041 JMP I ITLZO2 /RETURN TO CALLER ITLZO3, XX /TRANSLATOR INITIALIZATION SUBROUTINE /A012 / CLA /CLEAR AC /A012 DCA TRUNC /INITIALIZE TRUNCATION/ROUND FLAG = ROUND DCA MTHBLK /INITIALIZE "FORMULA CTRL WORD NOT FOUND" FLAG = TRUE TAD (OUTLST /GET LEAD ADDRESS OF OUTPUT LIST DCA OUTPTR /USE IT TO INIT OUTPUT LIST POINTER TAD (OUTLST /GET LEAD ADDRESS OF OUTPUT LIST DCA OUTENT /INIT FORMULA EXECUTION CODE ENTRY POINT /D041 JMS ITLZO1 /INIT LEAD LOCS OF OUTPUT LST TO SET UP AS SUBRTN TAD (INIT /GET JMP INDIRECT COMMAND TO HANDLE OUTPUT LIST /A041 JMS OUTTSZ /SAVE IT, INCREMENT PTR & TEST FOR OVERFLOW /A041 /PLACE "(JMP I OUTEXT" AT END OF OUTPUT LIST TO EXECUTE AS A ROUTINE TAD (JMP I OUTEXT /GET JMP I OUTEXT AND PUT AT END OF /A041 DCA I OUTPTR /OUTPUT LIST FOR USE BY EXECUTION CODE. /A041 TAD (OUTLST+1 /GET START ADDR OF OUTPUT LST + 1 TO SKIP "INIT"/A041 /VAL PUT AT START OF OUTPUT LIST FOR EXEC CODE /A041 DCA OUTPTR /INITIALIZE PTR TO OUTPUT LIST /A041 JMP I ITLZO3 /RETURN TO CALLER /A012 /D041 /SUBRTN TO INIT OUTPUT LIST PTR /A012 /D041 ITLZO4, XX /TRANSLATOR INIT SUBRTN /A012 /D041 TAD (OUTLST+1 /GET START ADDR OF OUTPUT LST + 1 TO SKIP "INIT"/A004 /D041 /VAL PUT AT START OF OUTPUT LIST FOR EXEC CODE /A004 /D041 DCA OUTPTR /INITIALIZE PTR TO OUTPUT LIST /D041 JMP I ITLZO4 /RETURN TO CALLER /A012 /WRKBUF, MOVED TO TMATH.PA TO MAKE ROOM FOR SYMBOL TABLE /A041 MAXWRK=12 /DEFINE LENGTH OF WORK BUFFER FOR Z-BLOCK /A041 WRKBUF, ZBLOCK MAXWRK /START ADDR OF CONTROL WORD WORK BUFFER /A041 UPWRK=. /UPPER LIMIT OF " " " " /A041 X=. / INDICATE FIRST FREE LOCATION /A041 / ------------------ PAGE /THIS ROUTINE CALLED AS AN INDIRECT THRU "HLDVAL" /ROUTINE TO PROCESS THE "FORMULA" CONTROL WORD FOUND IN A MATH CONTROL BLOCK MTHBLK, 0 /"FORMULA CONTROL WORD NOT FOUND" FLAG, KEEP ON SAME /PAGE WITH "FRMULA" ROUTINE FRMULA, XX /RTN TO HANDLE "FORMULA" CONTROL WORD TAD MTHBLK /GET "FORMULA CONTROL WORD NOT FOUND" FLAG SNA CLA /IS "FORMULA CONTROL WORD NOT FOUND" = TRUE? JMP FORM1 / YES: GO INITIALIZE TRANSLATOR DATA STRUCTURES JMP FORM2 / NO: BYPASS INITIALIZATION & SET FLAG PROCESS FORM1, ISZ MTHBLK /SET FORMULA CONTROL WORD NOT FOUND = FALSE /D041 JMS ITLZO4 /GO INITIALIZE OUTPUT LIST PTR /M012 TAD (OUTLST+1 /GET START ADDR OF OUTPUT LST + 1 TO SKIP "INIT"/A041 /VAL PUT AT START OF OUTPUT LIST FOR EXEC CODE /A041 DCA OUTPTR /INITIALIZE PTR TO OUTPUT LIST /A041 FORM2, AC0001 /SET UP TO INDICATE A FORMULA COMMAND /A039 DCA SETFLG /STORE IN FORMAT FLAG WORD /A039 JMS XLTFRM /CALL TRANSLATOR TO CONVERT FORMULA /NOTE: RETURN HERE WITH ERROR NUMBER IN THE AC IF THERE IS AN ERROR /IN THE MATH TRANSLATION PROCESSING JMP I FRMULA /RETURN HERE WITH ERROR NO. IN THE AC /NOTE: RETURN HERE IF PROCESSING WENT ALL RIGHT AC0001 /GET 1 INTO THE AC /A037 DCA MTHSND /SET "NOT PROCESSING SECOND LINE" = TRUE /A037 ISZ FRMULA /INCREMENT AC FOR NORMAL RETURN JMP I FRMULA /RETURN TO CALLER /THIS ROUTINE USED TO HANDLE A "SET" CONTROL WORD IN MATH CONTROL BLOCK SETCMD, XX /RTN TO HANDLE "SET" CONTROL WORD /M042 TAD OUTPTR /GET PRESENT POSITION OF OUTPUT LIST PTR DCA OUTENT /INIT FORMULA EXECUTION CODE ENTRY POINT DCA SETFLG /CLEAR FORMAT FLAG WORD TO INDICATE SET COMMAND /A039 /D041 JMS ITLZO1 /PUT LEAD VALUES INTO OUTPUT LIST FOR EXECUTION TAD (INIT /GET JMP INDIRECT COMMAND TO HANDLE OUTPUT LIST /A041 JMS OUTTSZ /SAVE IT, INCREMENT PTR & TEST FOR OVERFLOW /A041 /PLACE "(JMP I OUTEXT" AT END OF OUTPUT LIST TO EXECUTE AS A ROUTINE TAD (JMP I OUTEXT /GET JMP I OUTEXT AND PUT AT END OF /A041 DCA I OUTPTR /OUTPUT LIST FOR USE BY EXECUTION CODE. /A041 JMS XLTFRM /GO TRANSLATE FORMULA /NOTE: RETURN HERE WITH ERROR NUMBER IN THE AC IF THERE IS AN ERROR /IN THE MATH TRANSLATION PROCESSING JMP I SETCMD /RETURN HERE WITH ERROR NO. IN THE AC /M042 /NOTE: RETURN HERE IF PROCESSING WENT ALL RIGHT /GO INVOKE THE FORMULA EXECUTION CODE FOR THE "SET" CONTROL WORD JMS EXECUT /GO EXECUTE THE FORMULA TRANSLATED SZA /WAS AN ERROR RETURNED FROM THE EXECUTION CODE? JMP I SETCMD / YES: RETURN TO CALLER WITH ERROR NUMBER IN AC /M042 TAD OUTENT /GET ORIGINAL POSITION OF OUTPUT LIST PTR DCA OUTPTR /RESTORE IT NOW THAT THRU PROCESSING "SET" CTRL WORD /RESTORE "(JMP I OUTEXT" TO END OF LIST WHEN THRU WITH "SET" CTRL WORD TAD (JMP I OUTEXT /GET JMP I OUTEXT DCA I OUTPTR /SAVE IT AT END OF OUTPUT LIST BEFORE "SET" CTRL WORD /RESTORE FORMULA EXECUTION CODE ENTRY POINT TO START OF OUTPUT LIST TAD (OUTLST /GET START OF OUTPUT LIST DCA OUTENT /RESTORE FORMULA EXECUTION CODE ENTRY TO START OF LIST AC0001 /GET 1 INTO THE AC /A037 DCA MTHSND /SET "NOT PROCESSING SECOND LINE" = TRUE /A037 ISZ SETCMD /INCREMENT P.C. FOR NORMAL RETURN /M042 JMP I SETCMD /RETURN TO CALLER /M042 /THIS ROUTINE CALLED AS AN INDIRECT THRU "HLDVAL" /THIS ROUTINE USED TO HANDLE A "ROUND" CONTROL WORD IN MATH CONTROL BLOCK ROUND, XX /RTN TO HANDLE "ROUND" CONTROL WORD JMS CHKLNE /CHK FOR NON-ALLOWABLE CHARS ON SAME LINE AS.... /....AND RIGHT AFTER CONTROL WORD JMP ERRBCK /RETURN HERE FROM "CHKLNE" WITH ERROR NUM IN /A011 /AC TO PASS BACK IF NON-LEGAL CHARS FOUND ON LNE/A011 AC0000 /RETURN HERE FROM "CHKLNE" IF OK - SET AC TO ZERO DCA TRUNC /SET "TRUNCATE" FLAG = FALSE AC0001 /GET 1 INTO THE AC /A037 DCA MTHSND /SET "NOT PROCESSING SECOND LINE" = TRUE /A037 ISZ ROUND /SET P.C. FOR NORMAL RETURN JMP I ROUND /RETURN TO CALLER /THIS ROUTINE CALLED AS AN INDIRECT THRU "HLDVAL" /THIS ROUTINE USED TO HANDLE "TRUNCATE" CONTROL WORD IN MATH CONTROL BLOCK TRNCTE, XX /RTN TO HANDLE ":TRUNCATE" CONTROL WORD JMS CHKLNE /CHK FOR NON-ALLOWABLE CHARS ON SAME LINE AS.... /....AND RIGHT AFTER CONTROL WORD JMP ERRBCK /RETURN HERE FROM "CHKLNE" WITH ERROR NUM IN /A011 /AC TO PASS BACK IF NON-LEGAL CHARS FOUND ON LNE/A011 AC0001 /RETURN HERE FROM "CHKLNE" IF OK - SET AC TO 1 DCA TRUNC /SET "TRUNCATE" FLAG = TRUE AC0001 /GET 1 INTO THE AC /A037 DCA MTHSND /SET "NOT PROCESSING SECOND LINE" = TRUE /A037 ISZ TRNCTE /SET P.C. FOR NORMAL RETURN JMP I TRNCTE /RETURN TO CALLER /ROUTINE TO HANDLE "END" CONTROL WORD IN EDITOR MATH CONTROL BLOCK /A020 /MOVED IN FROM ANOTHER PAGE /A027 END, XX JMS CHKLNE /CHK FOR NON-ALLOWABLE CHARS ON SAME LINE AS... /A024 /....AND RIGHT AFTER CONTROL WORD /A024 JMP ERRBCK /RETURN HERE FROM "CHKLNE" WITH ERROR NUM IN AC /A026 /.. TO PASS BACK IF NON-LEGAL CHARS FOUND ON LNE/A026 TAD MTHSND /GET MATH CONTROL BLOCK "SECOND LINE" FLAG /A020 SZA CLA /ARE WE PROCESSING THE SECOND LINE? /A020 JMP ERROR5 / NO: REPORT ERROR - "END" ON WRONG LINE /A020 /D036 AC0001 / YES: GET 1 IN THE AC /A020 /D036 DCA MTHWRK /SET "START OF MATH WORK AREA" = FALSE /A020 AC7777 /GET -1 IN THE AC /A020 DCA MTHSND /SET "SECOND LINE" FLAG = "END" CTRL FOUND /A020 /D034 SETTING THIS FLAG WILL CAUSE THE MATH_END CODE TO BE INSERTED /A027 /D034 AFTER THE NEXT END_CONTROL /A027 /D034 CDFLP / FLAG IS IN LPFIELD /A027 /D034 AC0001 / /A027 /D034 DCA I (ENDFL) / SET FLAG /A027 ISZ END /SET UP SKIP FOR NORMAL RETURN /A020 JMP I END /RETURN TO CALLER /A020 ERROR5, TAD (EVSYN5 /RTRN "END" CTRL WORD ON WRONG LINE ERROR /M024 JMP I END /RETURN TO CALLER WITH ERROR NUMBER IN AC /A021 /THE FOLLOWING ROUTINE IS CALLED FROM OPDNUM TO CHECK IF THE CURRENT /A040 /NUMBER FROM LEXIC IS ALREADY IN THE SYMBOL TABLE. IF IT IS, WE DO /A040 /NOT WANT TO ADD ANOTHER COPY OF THE SAME NUMBER TO THE TABLE. /A040 / ENTER WITH AC CLEAR AND TOKVAL POINTING TO START OF NUMBER /A040 / RETURN TO CALLER IF NUMBER IS NOT IN SYMBOL TABLE /A040 / OTHERWISE, SET UP CORRECT POINTERS AND RETURN TO FLGFIX /A040 CHKNUM, XX /CHECK IF NUMBER IS IN SYMBOL TABLE /A040 TAD (SYMTBL /GET START OF SYMBOL TABLE ADDRESS /A040 DCA NUMPTR /SET UP POINTER TO POSSIBLE NUMBER LOCATION /A040 /CHECK TO SEE IF WE HAVE REACHED THE END OF THE SYMBOL TABLE YET /A040 CHKEND, TAD NUMPTR /GET CURRENT POINTER WITHIN SYMBOL TABLE /A040 CIA /MAKE IT NEGATIVE /A040 TAD SYMPTR /COMBINE WITH LAST USED LOCATION OF TABLE /A040 SPA SNA CLA /WAS NUMBER IN TABLE (HAVE WE REACHED THE END) /A040 JMP I CHKNUM /IT WASN'T, RETURN TO ADD IT TO SYMBOL TABLE /A040 /ARE WE POINTING TO A SYMBOL - ALL SYMBOLS START WITH A COLON CHARACTER /A040 TAD I NUMPTR /GET CURRENT CHARACTER POINTED TO /A040 TAD (200-": /SUBTRACT VALUE OF COLON FROM CHARACTER /A040 SZA CLA /IS IT A COLON /A040 JMP CHKVAL /NO: GO CHECK FOR NUMBER VALUE /A040 /SKIP OVER SYMBOL NAME IN TABLE /A040 CHKSYM, ISZ NUMPTR /BUMP POINTER TO NEXT LOCATION /A040 TAD I NUMPTR /GET CURRENT CHARACTER POINTER TO /A040 SMA CLA /IS IT THE LAST ONE OF THE SYMBOL NAME /A040 JMP CHKSYM /NO: GO CHECK THE NEXT ONE /A040 /SKIP OVER SYMBOL VALUE IN TABLE /A040 AC0002 /SET UP TO SKIP OVER LAST CHARACTER & FORMAT /A040 CHKNOT, TAD (VALSIZ /NUMBER OF CHARACTERS IN NUMBER VALUE /A040 TAD NUMPTR /COMBINE WITH CURRENT POINTER INTO SYM TABLE /A040 DCA NUMPTR /STORE POINTER TO NEXT TABLE ENTRY POINT /A040 JMP CHKEND /GO CHECK TO SEE IF THERE ARE ANY MORE ENTRIES /A040 /CHECK FOR NUMBER MATCH IN SYMBOL TABLE /A040 CHKVAL, TAD NUMPTR /GET POINTER TO NUMBER /A040 DCA TMPTR1 /SET UP TEMPORARY POINTER TO NUMBER /A040 TAD (TOKVAL /STARTING ADDRESS OF PASSED NUMERICAL OPERAND /A040 DCA TMPTR2 /SET UP POINTER TO NUMBER VALUE /A040 TAD (-VALSIZ /GET NEGATIVE NUMBER OF CHARACTERS TO CHECK /A040 DCA TMPCTR /SET UP COUNTER OF DIGITS TO CHECK /A040 CHKMOR, TAD I TMPTR1 /GET VALUE WORD FROM SYMBOL TABLE /A040 CIA /MAKE IT NEGATIVE /A040 TAD I TMPTR2 /COMBINE WITH VALUE WORD FROM LEXIC /A040 SZA CLA /DO THEY MATCH /A040 JMP CHKNOT /NO: GO UP THE POINTERS TO NEXT ENTRY /A040 ISZ TMPTR1 /BUMP SYMBOL TABLE POINTER /A040 ISZ TMPTR2 /BUMP LEXIC POINTER /A040 ISZ TMPCTR /BUMP COUNTER OF DIGITS LEFT TO DO /A040 JMP CHKMOR /NOT DONE, GO CHECK NEXT VALUE WORD /A040 /MATCH FOUND - NUMBER IS ALREADY IN THE SYMBOL TABLE LIST /A040 /PUT INPUT NUMBER ADDRESS AND "PUSH" RETURN ADDRESS INTO OUTPUT LIST /A040 TAD NUMPTR /GET ADDRESS OF INPUT OPERAND FROM SYMBOL TABLE /A041 JMS PSHLST /SAVE IT ON OUTPUT LIST /A041 JMP FLGFIX /GO SET FLAGS & EXIT OPERAND/OPERATOR ROUTINE /A041 /D041 TAD (PUSH /GET STARTING ADDRESS OF OUTPUT "PUSH" ROUTINE /A040 /D041 JMS OUTTSZ /SAVE IT, INCREMENT LST PTR & TEST FOR OVFLOW /A040 /D041 TAD NUMPTR /GET ADDRESS OF INPUT OPERAND FROM SYMBOL TABLE /A040 /D041 JMS OUTTSZ /SAVE IT, INCREMENT LST PTR & TEST FOR OVFLOW /A040 /D041 JMP FLGFIX /GO SET FLAGS & EXIT OPERAND/OPERATOR ROUTINE /A040 NUMPTR, 0 /PLACE TO SAVE START OF NUMBER IN SYMBOL TABLE /A040 X=. / INDICATE FIRST FREE LOCATION /A041 / ------------------ PAGE