![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to minimal CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / spitbol|
Return to minimal CVS log | Up to [Research Unix] / researchv10no / cmd / spitbol |
1.1 ! root 1: TTL MINIMAL -- MACHINE INDEPENDENT MACRO ASSEMBLY LANG. ! 2: EJC ! 3: * ! 4: * THE FOLLOWING SECTIONS DESCRIBE THE IMPLEMENTATION ! 5: * LANGUAGE ORIGINALLY DEVELOPED FOR SPITBOL BUT NOW MORE ! 6: * WIDELY USED. MINIMAL IS AN ASSEMBLY LANGUAGE ! 7: * FOR AN IDEALIZED MACHINE. THE FOLLOWING DESCRIBES THE ! 8: * BASIC CHARACTERISTICS OF THIS MACHINE. ! 9: * ! 10: * SECTION 1 - CONFIGURATION PARAMETERS ! 11: * ! 12: * THERE ARE SEVERAL PARAMETERS WHICH MAY VARY WITH THE ! 13: * TARGET MACHINE. THE MACRO-PROGRAM IS INDEPENDENT OF THE ! 14: * ACTUAL DEFINITIONS OF THESE PARAMETERS. ! 15: * ! 16: * THE DEFINITIONS OF THESE PARAMETERS ARE SUPPLIED BY ! 17: * THE TRANSLATION PROGRAM TO MATCH THE TARGET MACHINE. ! 18: * ! 19: * CFP$A NUMBER OF DISTINCT CHARACTERS IN ! 20: * INTERNAL ALPHABET IN THE RANGE ! 21: * 64 LE CFP$A LE MXLEN. ! 22: * ! 23: * CFP$B NUMBER OF BYTES IN A WORD WHERE A ! 24: * BYTE IS THE AMOUNT OF STORAGE ! 25: * ADDRESSED BY THE LEAST SIGNIFICANT ! 26: * ADDRESS BIT. ! 27: * ! 28: * CFP$C NUMBER OF CHARACTERS WHICH CAN ! 29: * BE STORED IN A SINGLE WORD. ! 30: * ! 31: * CFP$F BYTE OFFSET FROM START OF A STRING ! 32: * BLOCK TO THE FIRST CHARACTER. ! 33: * DEPENDS BOTH ON TARGET MACHINE AND ! 34: * STRING DATA STRUCTURE. SEE PLC, PSC ! 35: * ! 36: * CFP$I NUMBER OF WORDS IN A SIGNED ! 37: * INTEGER CONSTANT ! 38: * ! 39: * CFP$M THE LARGEST POSITIVE INTEGER ! 40: * OF FORM 2**N - 1 WHICH CAN BE ! 41: * STORED IN A SINGLE WORD. N ! 42: * WILL OFTEN BE CFP$N BUT NEED NOT BE ! 43: * ! 44: * ! 45: * CFP$N NUMBER OF BITS WHICH CAN BE STORED ! 46: * IN A ONE WORD BIT STRING. ! 47: * ! 48: * CFP$R NUMBER OF WORDS IN A REAL CONSTANT ! 49: * ! 50: * CFP$S NUMBER OF SIGNIFICANT DIGITS TO ! 51: * BE OUTPUT IN CONVERSION OF A REAL ! 52: * QUANTITY. THE INTEGER CONSISTING OF ! 53: * THIS NUMBER OF 9S MUST NOT BE TOO ! 54: * LARGE TO FIT IN THE INTEGER ACCUM. ! 55: * ! 56: * CFP$X NUMBER OF DIGITS IN REAL EXPONENT ! 57: EJC ! 58: * ! 59: * SECTION 2 - MEMORY ! 60: * ! 61: * MEMORY IS ORGANIZED INTO WORDS WHICH EACH CONTAIN CFP$B ! 62: * BYTES. FOR WORD MACHINES CFP$B, WHICH IS A CONFIGURATION ! 63: * PARAMETER, MAY BE ONE IN WHICH CASE WORDS AND BYTES ARE ! 64: * IDENTICAL. TO EACH WORD CORRESPONDS AN ADDRESS WHICH IS ! 65: * A NON-NEGATIVE QUANTITY WHICH IS A MULTIPLE OF CFP$B. ! 66: * DATA IS ORGANIZED INTO WORDS AS FOLLOWS. ! 67: * ! 68: * 1) A SIGNED INTEGER VALUE OCCUPIES CFP$I CONSECUTIVE ! 69: * WORDS (CFP$I IS A CONFIGURATION PARAMETER). ! 70: * THE RANGE MAY INCLUDE MORE NEGATIVE NUMBERS THAN ! 71: * POSITIVE (E.G. THE TWOS COMPLEMENT REPRESENTATION). ! 72: * ! 73: * 2) A SIGNED REAL VALUE OCCUPIES CFP$R CONSECUTIVE ! 74: * WORDS. (CFP$R IS A CONFIGURATION PARAMETER). ! 75: * ! 76: * 3) CFP$C CHARACTERS MAY BE STORED IN A SINGLE WORD ! 77: * (CFP$C IS A CONFIGURATION PARAMETER). ! 78: * ! 79: * 4) A BIT STRING CONTAINING CFP$N BITS CAN BE STORED IN ! 80: * A SINGLE WORD (CFP$N IS A CONFIGURATION PARAMETER). ! 81: * ! 82: * 5) A WORD CAN CONTAIN A NON-NEGATIVE INTEGER VALUE IN ! 83: * THE RANGE (0 LE N LE CFP$M). THESE INTEGER VALUES ! 84: * MAY REPRESENT ADDRESSES OF OTHER WORDS AND SOME OF ! 85: * THE INSTRUCTIONS USE THIS FACT TO PROVIDE INDEXING ! 86: * AND INDIRECTION FACILITIES. ! 87: * ! 88: * 6) PROGRAM INSTRUCTIONS OCCUPY WORDS IN AN UNDEFINED ! 89: * MANNER. DEPENDING ON THE ACTUAL IMPLEMENTATION, ! 90: * INSTRUCTIONS MAY OCCUPY SEVERAL WORDS, OR PART OF ! 91: * A WORD, OR EVEN BE SPLIT OVER WORD BOUNDARIES. ! 92: * ! 93: * THE FOLLOWING REGIONS OF MEMORY ARE AVAILABLE TO THE ! 94: * PROGRAM. EACH REGION CONSISTS OF A SERIES OF WORDS WITH ! 95: * CONSECUTIVE ADDRESSES. ! 96: * ! 97: * 1) CONSTANT SECTION ASSEMBLED CONSTANTS ! 98: * 2) WORKING STORAGE SECTION ASSEMBLED WORK AREAS ! 99: * 3) PROGRAM SECTION ASSEMBLED INSTRUCTIONS ! 100: * 4) STACK AREA ALLOCATED STACK AREA ! 101: * 5) DATA AREA ALLOCATED DATA AREA ! 102: EJC ! 103: * ! 104: * SECTION 3 - REGISTERS ! 105: * ! 106: * THERE ARE THREE INDEX REGISTERS CALLED XR,XL,XS. IN ! 107: * ADDITION XL MAY SOMETIMES BE REFERRED TO BY THE ALIAS ! 108: * OF XT - SEE SECTION 4. ANY OF THE ABOVE ! 109: * REGISTERS MAY HOLD A POSITIVE INTEGER IN THE RANGE ! 110: * (0 LE N LE CFP$M). WHEN THE INDEX REGISTER IS USED FOR ! 111: * INDEXING PURPOSES, THIS MUST BE AN APPROPRIATE ADDRESS. ! 112: * XS IS SPECIAL IN THAT IT IS USED TO POINT TO THE TOP ! 113: * ITEM OF A STACK IN MEMORY. THE STACK MAY BUILD UP OR ! 114: * DOWN IN MEMORY.SINCE IT IS REQUIRED THAT XS POINTS TO THE ! 115: * STACK TOP BUT ACCESS TO ITEMS BELOW THE TOP IS PERMITTED, ! 116: * REGISTERS XS AND XT MAY BE USED WITH SUITABLE OFFSETS ! 117: * TO INDEX STACKED ITEMS. ONLY XS AND XT MAY BE USED FOR ! 118: * THIS PURPOSE SINCE THE DIRECTION OF THE OFFSET IS ! 119: * TARGET MACHINE DEPENDENT. XT IS A SYNONYM FOR XL ! 120: * WHICH THEREFORE CANNOT BE USED IN CODE SEQUENCES ! 121: * REFERENCING XT. ! 122: * THE STACK IS USED FOR S-R LINKAGE AND TEMPORARY ! 123: * DATA STORAGE FOR WHICH THE STACK ARRANGEMENT IS SUITABLE. ! 124: * XR,XL CAN ALSO CONTAIN A CHARACTER POINTER IN CONJUNCTION ! 125: * WITH THE CHARACTER INSTRUCTIONS (SEE DESCRIPTION OF PLC). ! 126: EJC ! 127: * ! 128: * THERE ARE THREE WORK REGISTERS CALLED WA,WB,WC WHICH ! 129: * CAN CONTAIN ANY DATA ITEM WHICH CAN BE STORED IN A ! 130: * SINGLE MEMORY WORD. IN FACT, THE WORK REGISTERS ARE JUST ! 131: * LIKE MEMORY LOCATIONS EXCEPT THAT THEY HAVE NO ADDRESSES ! 132: * AND ARE REFERENCED IN A SPECIAL WAY BY THE INSTRUCTIONS. ! 133: * NOTE THAT REGISTERS WA,WB HAVE SPECIAL USES IN CONNECTION ! 134: * WITH THE CVD, CVM, MVC, MVW, MWB, CMC, TRC INSTRUCTIONS. ! 135: * REGISTER WC MAY OVERLAP THE INTEGER ACCUMULATOR (IA) IN ! 136: * SOME IMPLEMENTATIONS. THUS ANY OPERATION CHANGING THE ! 137: * VALUE IN WC LEAVES (IA) UNDEFINED AND VICE VERSA ! 138: * EXCEPT AS NOTED IN THE FOLLOWING RESTRICTION ON SIMPLE ! 139: * DUMP/RESTORE OPERATIONS. ! 140: * ! 141: * RESTRICTION ! 142: * ----------- ! 143: * ! 144: * IF IA AND WA OVERLAP THEN ! 145: * STI IASAV ! 146: * LDI IASAV ! 147: * DOES NOT CHANGE WC, AND ! 148: * MOV WC,WCSAV ! 149: * MOV WCSAV,WC ! 150: * DOES NOT CHANGE IA. ! 151: * ! 152: * ! 153: * ! 154: * THERE IS AN INTEGER ACCUMULATOR (IA) WHICH IS CAPABLE OF ! 155: * HOLDING A SIGNED INTEGER VALUE (CFP$I WORDS LONG). ! 156: * REGISTER WC MAY OVERLAP THE INTEGER ACCUMULATOR (IA) IN ! 157: * SOME IMPLEMENTATIONS. THUS ANY OPERATION CHANGING THE ! 158: * VALUE IN WC LEAVES (IA) UNDEFINED AND VICE VERSA ! 159: * EXCEPT AS NOTED IN THE ABOVE RESTRICTION ON SIMPLE ! 160: * DUMP/RESTORE OPERATIONS. ! 161: * ! 162: * ! 163: * ! 164: * THERE IS A SINGLE REAL ACCUMULATOR (RA) WHICH CAN HOLD ! 165: * ANY REAL VALUE AND IS COMPLETELY SEPARATE FROM ANY OF ! 166: * THE OTHER REGISTERS OR PROGRAM ACCESSIBLE LOCATIONS. ! 167: * ! 168: * ! 169: * ! 170: * THE CODE POINTER REGISTER (CP) IS A SPECIAL INDEX ! 171: * REGISTER FOR USE IN IMPLEMENTATIONS OF INTERPRETORS. ! 172: * IT IS USED TO CONTAIN A PSEUDO-CODE POINTER AND CAN ! 173: * ONLY BE AFFECTED BY ICP, LCP, SCP AND LCW INSTRUCTIONS. ! 174: EJC ! 175: * SECTION 4 - THE STACK ! 176: * ! 177: * THE FOLLOWING NOTES ARE TO GUIDE BOTH IMPLEMENTORS OF ! 178: * SYSTEMS WRITTEN IN MINIMAL AND MINIMAL PROGRAMMERS IN ! 179: * DEALING WITH STACK MANIPULATION. IMPLEMENTATION OF A ! 180: * DOWNWARDS BUILDING STACK IS EASIEST AND IN GENERAL IS ! 181: * TO BE PREFERRED, IN WHICH CASE IT IS MERELY NECESSARY TO ! 182: * CONSIDER XT AS AN ALTERNATIVE NAME FOR XL. ! 183: * ! 184: * THE MINIMAL VIRTUAL MACHINE INCLUDES A STACK AND HAS ! 185: * OPERAND FORMATS -(XS) AND (XS)+ FOR PUSHING AND POPPING ! 186: * ITEMS WITH AN IMPLICATION THAT THE STACK BUILDS DOWN IN ! 187: * MEMORY (A D-STACK). HOWEVER ON SOME TARGET MACHINES IT IS ! 188: * BETTER FOR THE STACK TO BUILD UP (A U-STACK). ! 189: * A STACK ADDRESSED ONLY BY PUSH AND POP OPERATIONS CAN ! 190: * BUILD IN EITHER DIRECTION WITH NO COMPLICATION BUT ! 191: * SUCH A PURE SCHEME OF STACK ACCESS PROVES RESTRICTIVE. ! 192: * HENCE IT IS PERMITTED TO ACCESS BURIED ITEMS USING AN ! 193: * INTEGER OFFSET PAST THE INDEX REGISTER POINTING TO THE ! 194: * STACK TOP. ON TARGET MACHINES THIS OFFSET WILL BE ! 195: * POSITIVE/NEGATIVE FOR D-STACKS/U-STACKS AND THIS MUST ! 196: * BE ALLOWED FOR IN THE TRANSLATION. ! 197: * A FURTHER RESTRICTION IS THAT AT NO TIME MAY AN ITEM BE ! 198: * PLACED ABOVE THE STACK TOP. FOR SOME OPERATIONS THIS ! 199: * MAKES IT CONVENIENT TO ADVANCE THE STACK POINTER AND THEN ! 200: * ADDRESS ITEMS BELOW IT USING A SECOND INDEX REGISTER. ! 201: * THE PROBLEM OF SIGNED OFFSETS PAST SUCH A REGISTER THEN ! 202: * ARISES. TO DISTINGUISH STACK OFFSETS, WHICH IN SOME ! 203: * IMPLEMENTATIONS MAY BE NEGATIVE, FROM NON-STACK OFFSETS ! 204: * WHICH ARE INVARIABLY POSITIVE, XT, AN ALIAS OR ! 205: * SYNONYM FOR XL IS USED. FOR A U-STACK IMPLEMENTATION, THE ! 206: * MINIMAL TRANSLATOR SHOULD NEGATE THE SIGN OF OFFSETS ! 207: * APPLIED TO BOTH (XS) AND (XT). ! 208: * PROGRAMMERS SHOULD NOTE THAT SINCE XT IS NOT A ! 209: * SEPARATE REGISTER, XL SHOULD NOT BE USED IN CODE WHERE ! 210: * XT IS REFERENCED. OTHER MODIFICATIONS NEEDED IN U-STACK ! 211: * TRANSLATIONS ARE IN THE ADD, SUB, ICA, DCA OPCODES ! 212: * APPLIED TO XS, XT. FOR EXAMPLE ! 213: * ! 214: * MINIMAL D-STACK TRANS. U-STACK TRANS. ! 215: * ! 216: * MOV WA,-(XS) SBI XS,1 ADI XS,1 ! 217: * STO WA,(XS) STO WA,(XS) ! 218: * MOV (XT)+,WC LOD WC,(XL) LOD WC,(XL) ! 219: * ADI XL,1 SBI XL,1 ! 220: * ADD =SEVEN,XS ADI XS,7 SBI XS,7 ! 221: * MOV 2(XT),WA LOD WA,2(XL) LOD WA,-2(XL) ! 222: * ICA XS ADI XS,1 SBI XS,1 ! 223: * ! 224: * NOTE THAT FORMS SUCH AS ! 225: * MOV -(XS),WA ! 226: * ADD WA,(XS)+ ! 227: * ARE ILLEGAL, SINCE THEY ASSUME INFORMATION STORAGE ! 228: * ABOVE THE STACK TOP. ! 229: EJC ! 230: * SECTION 5 - INTERNAL CHARACTER SET ! 231: * ! 232: * THE INTERNAL CHARACTER SET IS REPRESENTED BY A SET OF ! 233: * CONTIGUOUS CODES FROM 0 TO CFP$A-1. THE CODES FOR THE ! 234: * DIGITS 0-9 MUST BE CONTIGUOUS AND IN SEQUENCE. OTHER ! 235: * THAN THIS, THERE ARE NO RESTRAINTS. ! 236: * ! 237: * THE FOLLOWING SYMBOLS ARE AUTOMATICALLY DEFINED TO HAVE ! 238: * THE VALUE OF THE CORRESPONDING INTERNAL CHARACTER CODE. ! 239: * ! 240: * CH$LA LETTER A ! 241: * CH$LB LETTER B ! 242: * . . ! 243: * CH$L$ LETTER Z ! 244: * ! 245: * CH$D0 DIGIT 0 ! 246: * . . ! 247: * CH$D9 DIGIT 9 ! 248: * ! 249: * CH$AM AMPERSAND ! 250: * CH$AS ASTERISK ! 251: * CH$AT AT ! 252: * CH$BB LEFT BRACKET ! 253: * CH$BL BLANK ! 254: * CH$BR VERTICAL BAR ! 255: * CH$CL COLON ! 256: * CH$CM COMMA ! 257: * CH$DL DOLLAR SIGN ! 258: * CH$DT DOT (PERIOD) ! 259: * CH$DQ DOUBLE QUOTE ! 260: * CH$EQ EQUAL SIGN ! 261: * CH$EX EXCLAMATION MARK ! 262: * CH$MN MINUS ! 263: * CH$NM NUMBER SIGN ! 264: * CH$NT NOT ! 265: * CH$PC PERCENT ! 266: * CH$PL PLUS ! 267: * CH$PP LEFT PAREN ! 268: * CH$RB RIGHT BRACKET ! 269: * CH$RP RIGHT PAREN ! 270: * CH$QU QUESTION MARK ! 271: * CH$SL SLASH ! 272: * CH$SM SEMI-COLON ! 273: * CH$SQ SINGLE QUOTE ! 274: * CH$UN UNDERLINE ! 275: * ! 276: * THE FOLLOWING OPTIONAL SYMBOLS ARE INCORPORATED ! 277: * BY DEFINING THE CONDITIONAL ASSEMBLY SYMBOL NAMED. ! 278: * ! 279: * 26 SHIFTED LETTERS INCORPORATED BY DEFINING .CASL ! 280: * ! 281: * CH$$A SHIFTED A ! 282: * CH$$B SHIFTED B ! 283: * . . ! 284: * CH$$$ SHIFTED Z ! 285: * ! 286: * CH$HT HORIZONTAL TAB - DEFINE .CAHT ! 287: * CH$VT VERTICAL TAB - DEFINE .CAVT ! 288: EJC ! 289: * ! 290: * SECTION 6 - CONDITIONAL ASSEMBLY FEATURES ! 291: * ! 292: * SOME FEATURES OF THE INTERPRETER ARE APPLICABLE TO ONLY ! 293: * CERTAIN TARGET MACHINES. THEY MAY BE INCORPORATED OR ! 294: * OMITTED BY USE OF CONDITIONAL ASSEMBLY. THE FULL ! 295: * FORM OF A CONDITION IS - ! 296: * .IF CONDITIONAL ASSEMBLY SYMBOL (CAS) ! 297: * .THEN ! 298: * MINIMAL STATEMENTS1 (MS1) ! 299: * .ELSE ! 300: * MINIMAL STATEMENTS2 (MS2) ! 301: * .FI ! 302: * THE FOLLOWING RULES APPLY ! 303: * 1. THE DIRECTIVES .IF, .THEN, .ELSE, .FI MUST ! 304: * START IN COLUMN 1. ! 305: * 2. THE CONDITIONAL ASSEMBLY SYMBOL MUST START WITH A ! 306: * DOT IN COLUMN 8 FOLLOWED BY 4 LETTERS OR DIGITS E.G. ! 307: * .CA$1 ! 308: * 3. .THEN IS REDUNDANT AND MAY BE OMITTED IF WISHED. ! 309: * 4. MS1, MS2 ARE ARBITRARY SEQUENCES OF MINIMAL ! 310: * STATEMENTS EITHER OF WHICH MAY BE NULL. ! 311: * 5. IF MS2 IS OMITTED, .ELSE MAY ALSO BE OMITTED. ! 312: * 6. .FI IS REQUIRED. ! 313: * 7. CONDITIONS MAY BE NESTED TO A DEPTH DETERMINED ! 314: * BY THE TRANSLATOR (NOT LESS THAN 20, SAY). ! 315: * ! 316: * SELECTION OF THE ALTERNATIVES MS1, MS2 IS BY MEANS OF THE ! 317: * DEFINE AND UNDEFINE DIRECTIVES OF FORM - ! 318: * .DEF CAS ! 319: * .UNDEF CAS ! 320: * WHICH OBEY RULES 1. AND 2. ABOVE AND MAY OCCUR AT ANY ! 321: * POINT IN A MINIMAL PROGRAM, INCLUDING WITHIN A CONDITION. ! 322: * MULTIPLY DEFINING A SYMBOL IS AN ERROR. ! 323: * UNDEFINING A SYMBOL WHICH IS NOT DEFINED IS NOT AN ERROR. ! 324: * ! 325: * THE EFFECT IS THAT IF A SYMBOL IS CURRENTLY DEFINED, ! 326: * THEN IN ANY CONDITION DEPENDING ON IT, MS1 WILL BE ! 327: * PROCESSED AND MS2 OMITTED. CONVERSELY IF IT IS UNDEFINED, ! 328: * MS1 WILL BE OMITTED AND MS2 PROCESSED. ! 329: EJC ! 330: * ! 331: * SECTION 7 - OPERAND FORMATS ! 332: * ! 333: * THE FOLLOWING SECTION DESCRIBES THE VARIOUS POSSIBILITIES ! 334: * FOR OPERANDS OF INSTRUCTIONS AND ASSEMBLY OPERATIONS. ! 335: * ! 336: * 01 INT UNSIGNED INTEGER LE CFP$M ! 337: * 02 DLBL SYMBOL DEFINED IN DEFINITIONS SEC ! 338: * 03 WLBL LABEL IN WORKING STORAGE SECTION ! 339: * 04 CLBL LABEL IN CONSTANT SECTION ! 340: * 05 ELBL PROGRAM SECTION ENTRY LABEL ! 341: * 06 PLBL PROGRAM SECTION LABEL (NON-ENTRY) ! 342: * 07 X ONE OF THE THREE INDEX REGISTERS ! 343: * 08 W ONE OF THE THREE WORK REGISTERS ! 344: * 09 (X) LOCATION INDEXED BY X ! 345: * 10 (X)+ LIKE (X) BUT POST INCREMENT X ! 346: * 11 -(X) LIKE (X) BUT PREDECREMENT X ! 347: * 12 INT(X) LOCATION INT WORDS BEYOND ADDR IN X ! 348: * 13 DLBL(X) LOCATION DLBL WORDS PAST ADDR IN X ! 349: * 14 CLBL(X) LOCATION (X) BYTES BEYOND CLBL ! 350: * 15 WLBL(X) LOCATION (X) BYTES BEYOND WLBL ! 351: * 16 INTEGER SIGNED INTEGER (DIC) ! 352: * 17 REAL SIGNED REAL (DRC) ! 353: * 18 =DLBL LOCATION CONTAINING DAC DLBL ! 354: * 19 *DLBL LOCATION CONTAINING DAC CFP$B*DLBL ! 355: * 20 =WLBL LOCATION CONTAINING DAC WLBL ! 356: * 21 =CLBL LOCATION CONTAINING DAC CLBL ! 357: * 22 =ELBL LOCATION CONTAINING DAC ELBL ! 358: * 23 PNAM PROCEDURE LABEL (ON PRC INSTRUC) ! 359: * 24 EQOP OPERAND FOR EQU INSTRUCTION ! 360: * 25 PTYP PROCEDURE TYPE (SEE PRC) ! 361: * 26 TEXT ARBITRARY TEXT (ERB,ERR,TTL) ! 362: * 27 DTEXT DELIMITED TEXT STRING (DTC) ! 363: * ! 364: * THE NUMBERS IN THE ABOVE LIST ARE USED IN SUBSEQUENT ! 365: * DESCRIPTION AND IN SOME OF THE MINIMAL TRANSLATORS. ! 366: EJC ! 367: * ! 368: * OPERAND FORMATS (CONTINUED) ! 369: * ! 370: * THE FOLLOWING SPECIAL SYMBOLS REFER TO A COLLECTION OF ! 371: * THE LISTED POSSIBILITIES ! 372: * ! 373: * VAL 01,02 PREDEFINED VALUE ! 374: * ! 375: * VAL IS USED TO REFER TO A PREDEFINED ONE WORD ! 376: * INTEGER VALUE IN THE RANGE 0 LE N LE CFP$M. ! 377: * ! 378: * REG 07,08 REGISTER ! 379: * ! 380: * REG IS USED TO DESCRIBE AN OPERAND WHICH CAN BE ! 381: * ANY OF THE REGISTERS (XL,XR,XS,XT,WA,WB,WC). SUCH ! 382: * AN OPERAND CAN HOLD A ONE WORD INTEGER (ADDRESS). ! 383: * ! 384: * OPC 09,10,11 CHARACTER ! 385: * ! 386: * OPC IS USED TO DESIGNATE A SPECIFIC CHARACTER ! 387: * OPERAND FOR USE IN THE LCH AND SCH INSTRUCTIONS. ! 388: * THE INDEX REGISTER REFERENCED MUST BE EITHER XR OR ! 389: * XL (NOT XS,XT). SEE SECTION ON CHARACTER OPERATIONS. ! 390: * ! 391: * OPS 03,04,09,12,13,14,15 MEMORY REFERENCE ! 392: * ! 393: * OPS IS USED TO DESCRIBE AN OPERAND WHICH IS IN ! 394: * MEMORY. THE OPERAND MAY BE ONE OR MORE WORDS LONG ! 395: * DEPENDING ON THE DATA TYPE. IN THE CASE OF MULTIWORD ! 396: * OPERANDS, THE ADDRESS GIVEN IS THE FIRST WORD. ! 397: * ! 398: * OPW AS FOR OPS + 08,10,11 FULL WORD ! 399: * ! 400: * OPW IS USED TO REFER TO AN OPERAND WHOSE CAPACITY IS ! 401: * THAT OF A FULL MEMORY WORD. OPW INCLUDES ALL THE ! 402: * POSSIBILITIES FOR OPS (THE REFERENCED WORD IS USED) ! 403: * PLUS THE USE OF ONE OF THE THREE WORK REGISTERS ! 404: * (WA,WB,WC). IN ADDITION, THE FORMATS (X)+ AND -(X) ! 405: * ALLOW INDEXED OPERATIONS IN WHICH THE INDEX REGISTER ! 406: * IS POPPED BY ONE WORD AFTER THE REFERENCE (X)+, ! 407: * OR PUSHED BY ONE WORD BEFORE THE REFERENCE -(X) ! 408: * THESE LATTER TWO FORMATS PROVIDE A FACILITY FOR ! 409: * MANIPULATION OF STACKS. THE FORMAT DOES NOT IMPLY ! 410: * A PARTICULAR DIRECTION IN WHICH STACKS MUST BUILD - ! 411: * IT IS USED FOR COMPACTNESS. NOTE THAT THERE IS A ! 412: * RESTRICTION WHICH DISALLOWS AN INSTRUCTION TO USE ! 413: * AN INDEX REGISTER IN ONE OF THESE FORMATS ! 414: * IN SOME OTHER MANNER IN THE SAME INSTRUCTION. ! 415: * E.G. MOV XL,(XL)+ IS ILLEGAL. ! 416: * THE FORMATS -(X) AND (X)+ MAY ALSO BE USED IN ! 417: * PRE-DECREMENTATION, POST-INCREMENTATION TO ACCESS ! 418: * THE ADJACENT CHARACTER OF A STRING. ! 419: EJC ! 420: * ! 421: * OPERAND FORMATS (CONTINUED) ! 422: * ! 423: * OPN AS FOR OPW + 07 ONE WORD INTEGER ! 424: * ! 425: * OPN IS USED TO REPRESENT AN OPERAND LOCATION WHICH ! 426: * CAN CONTAIN A ONE WORD INTEGER (E.G. AN ADDRESS). ! 427: * THIS INCLUDES ALL THE POSSIBILITIES FOR OPW PLUS ! 428: * THE USE OF ONE OF THE INDEX REGISTERS (XL,XR,XT, ! 429: * XS). THE RANGE OF INTEGER VALUES IS 0 LE N LE CFP$M. ! 430: * ! 431: * OPV AS FOR OPN + 18-22 ONE WORD INTEGER VALUE ! 432: * ! 433: * OPV IS USED FOR AN OPERAND WHICH CAN YIELD A ONE ! 434: * WORD INTEGER VALUE (E.G. AN ADDRESS). IT INCLUDES ! 435: * ALL THE POSSIBILITIES FOR OPN (THE CURRENT VALUE OF ! 436: * THE LOCATION IS USED) PLUS THE USE OF LITERALS. NOTE ! 437: * THAT ALTHOUGH THE LITERAL FORMATS ARE DESCRIBED IN ! 438: * TERMS OF A REFERENCE TO A LOCATION CONTAINING AN ! 439: * ADDRESS CONSTANT, THIS LOCATION MAY NOT ACTUALLY ! 440: * EXIST IN SOME IMPLEMENTATIONS SINCE ONLY THE VALUE ! 441: * IS REQUIRED. A RESTRICTION IS PLACED ON LITERALS ! 442: * WHICH MAY CONSIST ONLY OF DEFINED SYMBOLS AND ! 443: * CERTAIN LABELS. CONSEQUENTLY SMALL INTEGERS TO BE ! 444: * USED AS LITERALS MUST BE PRE-DEFINED, A DISCIPLINE ! 445: * AIDING PROGRAM MAINTENANCE AND REVISION. ! 446: * ! 447: * ADDR 01,02,03,04,05 ADDRESS ! 448: * ! 449: * ADDR IS USED TO DESCRIBE AN EXPLICIT ADDRESS VALUE ! 450: * (ONE WORD INTEGER VALUE) FOR USE WITH DAC. ! 451: * ! 452: * ! 453: * **************************************************** ! 454: * * IN THE FOLLOWING DESCRIPTIONS THE USAGE -- * ! 455: * * (XL),(XR), ... ,(IA) * ! 456: * * IN THE DESCRIPTIVE TEXT SIGNIFIES THE + ! 457: * * CONTENTS OF THE STATED REGISTER. * ! 458: * **************************************************** ! 459: EJC ! 460: * ! 461: * SECTION 8 - LIST OF INSTRUCTION MNEMONICS ! 462: * ! 463: * THE FOLLOWING LIST INCLUDES ALL INSTRUCTION AND ! 464: * ASSEMBLY OPERATION MNEMONICS IN ALPHABETICAL ORDER. ! 465: * THE MNEMONICS ARE PRECEDED BY A NUMBER IDENTIFYING ! 466: * THE FOLLOWING SECTION WHERE THE INSTRUCTION IS DESCRIBED. ! 467: * A STAR (*) IS APPENDED TO THE MNEMONIC IF THE LAST ! 468: * OPERAND MAY OPTIONALLY BE OMITTED. ! 469: * SEE SECTION -15- FOR DETAILS OF STATEMENT FORMAT AND ! 470: * COMMENT CONVENTIONS. ! 471: * ! 472: * 2.1 ADD OPV,OPN ADD ADDRESS ! 473: * 4.2 ADI OPS ADD INTEGER ! 474: * 5.3 ADR OPS ADD REAL ! 475: * 7.1 ANB OPW,W AND BIT STRING ! 476: * 2.17 AOV OPV,OPN,PLBL ADD ADDRESS, FAIL IF OVERFLOW ! 477: * 2.16 BCT W,PLBL BRANCH AND COUNT ! 478: * 2.5 BEQ OPN,OPV,PLBL BRANCH IF ADDRESS EQUAL ! 479: * 2.8 BGE OPN,OPV,PLBL BRANCH IF ADDRESS GREATER OR EQUL ! 480: * 2.7 BGT OPN,OPV,PLBL BRANCH IF ADDRESS GREATER ! 481: * 2.12 BHI OPN,OPV,PLBL BRANCH IF ADDRESS HIGH ! 482: * 2.10 BLE OPN,OPV,PLBL BRANCH IF ADDRESS LESS OR EQUAL ! 483: * 2.11 BLO OPN,OPV,PLBL BRANCH IF ADDRESS LOW ! 484: * 2.9 BLT OPN,OPV,PLBL BRANCH IF ADDRESS LESS THAN ! 485: * 2.6 BNE OPN,OPV,PLBL BRANCH IF ADDRESS NOT EQUAL ! 486: * 2.13 BNZ OPN,PLBL BRANCH IF ADDRESS NON-ZERO ! 487: * 1.2 BRN PLBL BRANCH UNCONDITIONAL ! 488: * 1.7 BRI OPN BRANCH INDIRECT ! 489: * 1.3 BSW* X,VAL,PLBL BRANCH ON SWITCH VALUE ! 490: * 8.2 BTW REG CONVERT BYTES TO WORDS ! 491: * 2.14 BZE OPN,PLBL BRANCH IF ADDRESS ZERO ! 492: * 6.6 CEQ OPW,OPW,PLBL BRANCH IF CHARACTERS EQUAL ! 493: * 10.1 CHK CHECK STACK OVERFLOW ! 494: * 7.4 CMB W COMPLEMENT BIT STRING ! 495: * 6.8 CMC PLBL,PLBL COMPARE CHARACTER STRINGS ! 496: * 6.7 CNE OPW,OPW,PLBL BRANCH IF CHARACTERS NOT EQUAL ! 497: * 6.5 CSC X COMPLETE STORE CHARACTERS ! 498: * 8.8 CTB W,VAL CONVERT CHARACTER COUNT TO BYTES ! 499: * 8.7 CTW W,VAL CONVERT CHARACTER COUNT TO WORDS ! 500: * 8.10 CVD CONVERT BY DIVISION ! 501: * 8.9 CVM PLBL CONVERT BY MULTIPLICATION ! 502: * 11.1 DAC ADDR DEFINE ADDRESS CONSTANT ! 503: * 11.5 DBC VAL DEFINE BIT STRING CONSTANT ! 504: * 2.4 DCA OPN DECREMENT ADDRESS BY ONE WORD ! 505: * 1.17 DCV OPN DECREMENT VALUE BY ONE ! 506: * 11.2 DIC INTEGER DEFINE INTEGER CONSTANT ! 507: EJC ! 508: * ! 509: * ALPHABETICAL LIST OF MNEMONICS (CONTINUED) ! 510: * ! 511: * 11.3 DRC REAL DEFINE REAL CONSTANT ! 512: * 11.4 DTC DTEXT DEFINE TEXT (CHARACTER) CONSTANT ! 513: * 4.5 DVI OPS DIVIDE INTEGER ! 514: * 5.6 DVR OPS DIVIDE REAL ! 515: * 13.1 EJC EJECT ASSEMBLY LISTING ! 516: * 14.2 END END OF ASSEMBLY ! 517: * 1.13 ENP DEFINE END OF PROCEDURE ! 518: * 1.6 ENT* VAL DEFINE ENTRY POINT ! 519: * 12.1 EQU EQOP DEFINE SYMBOLIC VALUE ! 520: * 1.15 ERB INT,TEXT ASSEMBLE ERROR CODE AND BRANCH ! 521: * 1.14 ERR INT,TEXT ASSEMBLE ERROR CODE ! 522: * 1.5 ESW END OF SWITCH LIST FOR BSW ! 523: * 1.12 EXI* INT EXIT FROM PROCEDURE ! 524: * 12.2 EXP DEFINE EXTERNAL PROCEDURE ! 525: * 2.3 ICA OPN INCREMENT ADDRESS BY ONE WORD ! 526: * 3.4 ICP INCREMENT CODE POINTER ! 527: * 1.16 ICV OPN INCREMENT VALUE BY ONE ! 528: * 4.11 IEQ PLBL JUMP IF INTEGER ZERO ! 529: * 1.4 IFF VAL,PLBL SPECIFY BRANCH FOR BSW ! 530: * 4.12 IGE PLBL JUMP IF INTEGER NON-NEGATIVE ! 531: * 4.13 IGT PLBL JUMP IF INTEGER POSITIVE ! 532: * 4.14 ILE PLBL JUMP IF INTEGER NEGATIVE OR ZERO ! 533: * 4.15 ILT PLBL JUMP IF INTEGER NEGATIVE ! 534: * 4.16 INE PLBL JUMP IF INTEGER NON-ZERO ! 535: * 4.9 INO PLBL JUMP IF NO INTEGER OVERFLOW ! 536: * 12.3 INP PTYP,INT INTERNAL PROCEDURE ! 537: * 12.4 INR INTERNAL ROUTINE ! 538: * 4.10 IOV PLBL JUMP IF INTEGER OVERFLOW ! 539: * 8.5 ITR CONVERT INTEGER TO REAL ! 540: * 1.9 JSR PNAM CALL PROCEDURE ! 541: * 6.3 LCH REG,OPC LOAD CHARACTER ! 542: * 2.15 LCT W,OPV LOAD COUNTER FOR LOOP ! 543: * 3.1 LCP REG LOAD CODE POINTER REGISTER ! 544: * 3.3 LCW REG LOAD NEXT CODE WORD ! 545: * 4.1 LDI OPS LOAD INTEGER ! 546: * 5.1 LDR OPS LOAD REAL ! 547: * 1.8 LEI X LOAD ENTRY POINT ID ! 548: * 7.6 LSH W,VAL LEFT SHIFT BIT STRING ! 549: * 7.8 LSX W,(X) LEFT SHIFT INDEXED ! 550: * 8.4 MFI* OPN,PLBL CONVERT (IA) TO ADDRESS VALUE ! 551: * 4.3 MLI OPS MULTIPLY INTEGER ! 552: * 5.5 MLR OPS MULTIPLY REAL ! 553: * 1.19 MNZ OPN MOVE NON-ZERO ! 554: * 1.1 MOV OPV,OPN MOVE ! 555: * 8.3 MTI OPN MOVE ADDRESS VALUE TO (IA) ! 556: * 9.1 MVC MOVE CHARACTERS ! 557: * 9.2 MVW MOVE WORDS ! 558: * 9.3 MWB MOVE WORDS BACKWARDS ! 559: * 4.8 NGI NEGATE INTEGER ! 560: EJC ! 561: * ! 562: * ALPHABETICAL LIST OF MNEMONICS (CONTINUED) ! 563: * ! 564: * 5.9 NGR NEGATE REAL ! 565: * 7.9 NZB W,PLBL JUMP IF NOT ALL ZERO BITS ! 566: * 7.2 ORB OPW,W OR BIT STRINGS ! 567: * 6.1 PLC* X,OPV PREPARE TO LOAD CHARACTERS ! 568: * 1.10 PPM* PLBL PROVIDE PROCEDURE EXIT PARAMETER ! 569: * 1.11 PRC PTYP,VAL DEFINE START OF PROCEDURE ! 570: * 6.2 PSC* X,OPV PREPARE TO STORE CHARACTERS ! 571: * 5.10 REQ PLBL JUMP IF REAL ZERO ! 572: * 5.11 RGE PLBL JUMP IF REAL POSITIVE OR ZERO ! 573: * 5.12 RGT PLBL JUMP IF REAL POSITIVE ! 574: * 5.13 RLE PLBL JUMP IF REAL NEGATIVE OR ZERO ! 575: * 5.14 RLT PLBL JUMP IF REAL NEGATIVE ! 576: * 4.6 RMI OPS REMAINDER INTEGER ! 577: * 5.15 RNE PLBL JUMP IF REAL NON-ZERO ! 578: * 5.8 RNO PLBL JUMP IF NO REAL OVERFLOW ! 579: * 5.7 ROV PLBL JUMP IF REAL OVERFLOW ! 580: * 7.5 RSH W,VAL RIGHT SHIFT BIT STRING ! 581: * 7.7 RSX W,(X) RIGHT SHIFT INDEXED ! 582: * 8.6 RTI* PLBL CONVERT REAL TO INTEGER ! 583: * 1.22 RTN DEFINE START OF ROUTINE ! 584: * 4.4 SBI OPS SUBTRACT INTEGER ! 585: * 5.4 SBR OPS SUBTRACT REALS ! 586: * 6.4 SCH REG,OPC STORE CHARACTER ! 587: * 3.2 SCP REG STORE CODE POINTER ! 588: * 14.1 SEC DEFINE START OF ASSEMBLY SECTION ! 589: * 1.20 SSL OPW SUBROUTINE STACK LOAD ! 590: * 1.21 SSS OPW SUBROUTINE STACK STORE ! 591: * 4.7 STI OPS STORE INTEGER ! 592: * 5.2 STR OPS STORE REAL ! 593: * 2.2 SUB OPV,OPN SUBTRACT ADDRESS ! 594: * 6.9 TRC TRANSLATE CHARACTER STRING ! 595: * 13.2 TTL TEXT SUPPLY ASSEMBLY TITLE ! 596: * 8.1 WTB REG CONVERT WORDS TO BYTES ! 597: * 7.3 XOB OPW,W EXCLUSIVE OR BIT STRINGS ! 598: * 1.18 ZER OPN ZEROISE INTEGER LOCATION ! 599: * 7.11 ZGB OPN ZEROISE GARBAGE BITS ! 600: * 7.10 ZRB W,PLBL JUMP IF ALL ZERO BITS ! 601: EJC ! 602: * ! 603: * SECTION 9 - MINIMAL INSTRUCTIONS ! 604: * ! 605: * THE FOLLOWING DESCRIPTIONS ASSUME THE DEFINITIONS - ! 606: * ! 607: * ZEROE EQU 0 ! 608: * UNITY EQU 1 ! 609: * ! 610: * -1- BASIC INSTRUCTION SET ! 611: * ! 612: * 1.1 MOV OPV,OPN MOVE ONE WORD VALUE ! 613: * ! 614: * MOV CAUSES THE VALUE OF OPERAND OPV TO BE SET AS ! 615: * THE NEW CONTENTS OF OPERAND LOCATION OPN. IN THE ! 616: * CASE WHERE OPN IS NOT AN INDEX REGISTER, ANY VALUE ! 617: * WHICH CAN NORMALLY OCCUPY A MEMORY WORD (INCLUDING ! 618: * A PART OF A MULTIWORD REAL OR INTEGER VALUE) ! 619: * CAN BE TRANSFERRED USING MOV. IF THE TARGET LOCATION ! 620: * OPN IS AN INDEX REGISTER, THEN OPV MUST SPECIFY AN ! 621: * APPROPRIATE ONE WORD VALUE OR OPERAND CONTAINING ! 622: * SUCH AN APPROPRIATE VALUE. ! 623: * ! 624: * 1.2 BRN PLBL UNCONDITIONAL BRANCH ! 625: * ! 626: * BRN CAUSES CONTROL TO BE PASSED TO THE INDICATED ! 627: * LABEL IN THE PROGRAM SECTION. ! 628: * ! 629: * 1.3 BSW X,VAL,PLBL BRANCH ON SWITCH VALUE ! 630: * 1.4 IFF VAL,PLBL PROVIDE BRANCH FOR SWITCH ! 631: * IFF VAL,PLBL ... ! 632: * ... ! 633: * ... ! 634: * 1.5 ESW END OF BRANCH SWITCH TABLE ! 635: * ! 636: * BSW,IFF,ESW PROVIDE A CAPABILITY FOR A SWITCHED ! 637: * BRANCH SIMILAR TO A FORTRAN COMPUTED GOTO. THE ! 638: * VAL ON THE BSW INSTRUCTION IS THE MAXIMUM NUMBER ! 639: * OF BRANCHES. THE VALUE IN X RANGES FROM ZERO UP TO ! 640: * BUT NOT INCLUDING THIS MAXIMUM. EACH IFF PROVIDES A ! 641: * BRANCH. VAL MUST BE LESS THAN THAT GIVEN ON THE BSW ! 642: * AND CONTROL GOES TO PLBL IF THE VALUE IN X MATCHES. ! 643: * IF THE VALUE IN X DOES NOT CORRESPOND TO ANY OF THE ! 644: * IFF ENTRIES, THEN CONTROL PASSES TO THE PLBL ON THE ! 645: * BSW. THIS PLBL OPERAND MAY BE OMITTED IF THERE ARE ! 646: * NO VALUES MISSING FROM THE LIST. ! 647: * ! 648: * IFF AND ESW MAY ONLY BE USED IN THIS CONTEXT. ! 649: * EXECUTION OF BSW MAY DESTROY THE CONTENTS OF X. ! 650: * THE IFF ENTRIES MAY BE IN ANY ORDER AND SINCE ! 651: * A TRANSLATOR MAY THUS NEED TO STORE AND SORT THEM, ! 652: * THE COMMENT FIELD IS RESTRICTED IN LENGTH (SEC 11). ! 653: EJC ! 654: * ! 655: * -1- BASIC INSTRUCTIONS (CONTINUED) ! 656: * ! 657: * 1.6 ENT VAL DEFINE PROGRAM ENTRY POINT ! 658: * ! 659: * THE SYMBOL APPEARING IN THE LABEL FIELD IS DEFINED ! 660: * TO BE A PROGRAM ENTRY POINT WHICH CAN SUBSEQUENTLY ! 661: * BE USED IN CONJUNCTION WITH THE BRI INSTRUCTION, ! 662: * WHICH PROVIDES THE ONLY MEANS OF ENTERING THE ! 663: * CODE. IT IS ILLEGAL TO FALL INTO CODE ! 664: * IDENTIFIED BY AN ENTRY POINT. THE ! 665: * ENTRY SYMBOL IS ASSIGNED AN ADDRESS WHICH NEED NOT ! 666: * BE A MULTIPLE OF CFP$B BUT WHICH MUST BE IN THE ! 667: * RANGE 0 LE CFP$M AND THE ADDRESS MUST NOT LIE WITHIN ! 668: * THE ADDRESS RANGE OF THE ALLOCATED DATA AREA. ! 669: * FURTHERMORE, ADDRESSES OF SUCCESSIVE ENTRY POINTS ! 670: * MUST BE ASSIGNED IN SOME ASCENDING SEQUENCE SO ! 671: * THAT THE ADDRESS COMPARISON INSTRUCTIONS CAN BE ! 672: * USED TO TEST THE ORDER IN WHICH TWO ENTRY POINTS ! 673: * OCCUR. THE SYMBOL VAL GIVES AN IDENTIFYING VALUE ! 674: * TO THE ENTRY POINT WHICH CAN BE ACCESSED WITH THE ! 675: * LEI INSTRUCTION. ! 676: * NOTE - SUBJECT TO THE RESTRICTION BELOW, VAL MAY ! 677: * BE OMITTED IF NO SUCH IDENTIFICATION IS NEEDED I.E. ! 678: * IF NO LEI REFERENCES THE ENTRY POINT. FOR THIS ! 679: * CASE, A TRANSLATION OPTIMISATION IS POSSIBLE IN ! 680: * WHICH NO MEMORY NEED BE RESERVED FOR A NULL ! 681: * IDENTIFICATION WHICH IS NEVER TO BE REFERENCED, BUT ! 682: * ONLY PROVIDED THIS IS DONE SO AS NOT TO INTERFERE ! 683: * WITH THE STRICTLY ASCENDING SEQUENCE OF ENTRY POINT ! 684: * ADDRESSES. TO SIMPLIFY THIS OPTIMISATION FOR ALL ! 685: * IMPLEMENTORS, THE FOLLOWING RESTRICTION IS OBSERVED ! 686: * VAL MAY ONLY BE OMITTED IF THE ENTRY POINT IS ! 687: * SEPARATED FROM A FOLLOWING ENTRY POINT BY A ! 688: * NON-NULL MINIMAL CODE SEQUENCE. ! 689: * ENTRY POINT ADDRESSES ARE ACCESSIBLE ONLY BY USE OF ! 690: * LITERALS (=ELBL, SECTION 7) OR DAC CONSTANTS ! 691: * (SECTION 8-11.1). ! 692: * ! 693: * 1.7 BRI OPN BRANCH INDIRECT ! 694: * ! 695: * OPN CONTAINS THE ADDRESS OF A PROGRAM ENTRY POINT ! 696: * (SEE ENT). CONTROL IS PASSED TO THE EXECUTABLE ! 697: * CODE STARTING AT THE ENTRY POINT ADDRESS. OPN IS ! 698: * LEFT UNCHANGED. ! 699: * ! 700: * 1.8 LEI X LOAD ENTRY POINT IDENTIFICATION ! 701: * ! 702: * X CONTAINS THE ADDRESS OF AN ENTRY POINT FOR WHICH ! 703: * AN IDENTIFYING VALUE WAS GIVEN ON THE THE ENT LINE. ! 704: * LEI REPLACES THE CONTENTS OF X BY THIS VALUE. ! 705: EJC ! 706: * ! 707: * -1- BASIC INSTRUCTIONS (CONTINUED) ! 708: * ! 709: * 1.9 JSR PNAM CALL PROCEDURE PNAM ! 710: * 1.10 PPM PLBL PROVIDE EXIT PARAMETER ! 711: * PPM PLBL ... ! 712: * ... ! 713: * PPM PLBL ... ! 714: * ! 715: * JSR CAUSES CONTROL TO BE PASSED TO THE NAMED ! 716: * PROCEDURE. PNAM IS THE LABEL ON A PRC STATEMENT ! 717: * ELSEWHERE IN THE PROGRAM SECTION (SEE PRC) ! 718: * OR HAS BEEN DEFINED USING AN EXP INSTRUCTION. ! 719: * THE PPM EXIT PARAMETERS FOLLOWING THE CALL GIVE ! 720: * NAMES OF PROGRAM LOCATIONS (PLBL-S) TO WHICH ! 721: * ALTERNATIVE EXI RETURNS OF THE CALLED PROCEDURE MAY ! 722: * PASS CONTROL. THEY MAY OPTIONALLY BE REPLACED BY ! 723: * ERROR RETURNS (SEE ERR). THE NUMBER OF EXIT ! 724: * PARAMETERS FOLLOWING A JSR MUST EQUAL THE INT IN THE ! 725: * PROCEDURE DEFINITION. THE OPERAND OF PPM MAY BE ! 726: * OMITTED IF THE CORRESPONDING EXI RETURN IS CERTAIN ! 727: * NOT TO BE TAKEN. ! 728: * ! 729: * 1.11 PRC PTYP,INT DEFINE START OF PROCEDURE ! 730: * ! 731: * THE SYMBOL APPEARING IN THE LABEL FIELD IS DEFINED ! 732: * TO BE THE NAME OF A PROCEDURE FOR USE WITH JSR. ! 733: * A PROCEDURE IS A CONTIGUOUS SECTION OF INSTRUCTIONS ! 734: * TO WHICH CONTROL MAY BE PASSED WITH A JSR ! 735: * INSTRUCTION. THIS IS THE ONLY WAY IN WHICH THE ! 736: * INSTRUCTIONS IN A PROCEDURE MAY BE EXECUTED. IT IS ! 737: * NOT PERMITTED TO FALL INTO A PROCEDURE. ! 738: * ALL PROCEDURES SHOULD BE NAMED IN SECTION 0 ! 739: * INP STATEMENTS. ! 740: * ! 741: * INT IS THE NUMBER OF EXIT PARAMETERS (PPM-S) TO ! 742: * BE USED IN JSR CALLS. ! 743: * ! 744: * THERE ARE THREE POSSIBILITIES FOR PTYP, EACH ! 745: * CONSISTING OF A SINGLE LETTER AS FOLLOWS. ! 746: * ! 747: * R RECURSIVE ! 748: * ! 749: * THE RETURN POINT (ONE OR MORE WORDS) IS STORED ON ! 750: * THE STACK AS THOUGH ONE OR MORE MOV ..,-(XS) ! 751: * INSTRUCTIONS WERE EXECUTED. ! 752: EJC ! 753: * ! 754: * -1- BASIC INSTRUCTIONS (CONTINUED) ! 755: * ! 756: * N NON-RECURSIVE ! 757: * ! 758: * THE RETURN POINT IS TO BE STORED EITHER ! 759: * (1) IN A LOCAL STORAGE WORD ASSOCIATED ! 760: * WITH THE PROCEDURE AND NOT DIRECTLY ! 761: * AVAILABLE TO THE PROGRAM IN ANY OTHER MANNER OR ! 762: * (2) ON A SUBROUTINE LINK STACK QUITE DISTINCT FROM ! 763: * THE MINIMAL STACK ADDRESSED BY XS. ! 764: * IT IS AN ERROR TO USE THE STACK FOR N-LINKS, SINCE ! 765: * PROCEDURE PARAMETERS OR RESULTS MAY BE PASSED VIA ! 766: * THE STACK. ! 767: * IF METHOD (2) IS USED FOR LINKS, ERROR EXITS ! 768: * (ERB,ERR) FROM A PROCEDURE WILL NECESSITATE LINK ! 769: * STACK RESETTING. THE SSL AND SSS ORDERS PROVIDED ! 770: * FOR THIS MAY BE REGARDED AS NO-OPS FOR ! 771: * IMPLEMENTATIONS USING METHOD (1). ! 772: * ! 773: * E EITHER ! 774: * ! 775: * THE RETURN POINT MAY BE STORED IN EITHER MANNER ! 776: * ACCORDING TO EFFICIENCY REQUIREMENTS OF THE ACTUAL ! 777: * PHYSICAL MACHINE USED FOR THE IMPLEMENTATION. NOTE ! 778: * THAT PROGRAMMING OF E TYPE PROCEDURES MUST BE ! 779: * INDEPENDENT OF THE ACTUAL IMPLEMENTATION. ! 780: * ! 781: * THE ACTUAL FORM OF THE RETURN POINT IS UNDEFINED. ! 782: * HOWEVER, EACH WORD STORED ON THE STACK FOR AN ! 783: * R-TYPE CALL MUST MEET THE FOLLOWING REQUIREMENTS. ! 784: * ! 785: * 1) IT CAN BE HANDLED AS AN ADDRESS ! 786: * AND PLACED IN AN INDEX REGISTER. ! 787: * ! 788: * 2) WHEN USED AS AN OPERAND IN AN ! 789: * ADDRESS COMPARISON INSTRUCTION, IT ! 790: * MUST NOT APPEAR TO LIE WITHIN ! 791: * THE ALLOCATED DATA AREA. ! 792: * ! 793: * 3) IT IS NOT REQUIRED TO APPEAR ! 794: * TO LIE WITHIN THE PROGRAM SECTION. ! 795: EJC ! 796: * ! 797: * -1- BASIC INSTRUCTIONS (CONTINUED) ! 798: * ! 799: * 1.12 EXI INT EXIT FROM PROCEDURE ! 800: * ! 801: * THE PPM AND ERR PARAMETERS FOLLOWING A JSR ARE ! 802: * NUMBERED STARTING FROM 1. EXI INT CAUSES CONTROL ! 803: * TO BE RETURNED TO THE INT-TH SUCH PARAM. EXI 1 GIVES ! 804: * CONTROL TO THE PLBL OF THE FIRST PPM AFTER THE JSR. ! 805: * IF INT IS OMITTED, CONTROL IS PASSED BACK PAST THE ! 806: * LAST EXIT PARAMETER (OR PAST THE JSR IF THERE ARE ! 807: * NONE). FOR R AND E TYPE PROCEDURES, THE ! 808: * STACK POINTER XS MUST BE SET TO ITS APPROPRIATE ! 809: * ENTRY VALUE BEFORE EXECUTING AN EXI INSTRUCTION. ! 810: * IN THIS CASE, EXI REMOVES RETURN POINTS FROM THE ! 811: * STACK IF ANY ARE STORED THERE SO THAT THE STACK ! 812: * POINTER IS RESTORED TO ITS CALLING VALUE. ! 813: * ! 814: * 1.13 ENP DEFINE END OF PROCEDURE BODY ! 815: * ! 816: * ENP DELIMITS A PROCEDURE BODY AND MAY NOT ACTUALLY ! 817: * BE EXECUTED, HENCE IT MUST HAVE NO LABEL. ! 818: * ! 819: * 1.14 ERR INT,TEXT PROVIDE ERROR RETURN ! 820: * ! 821: * ERR MAY REPLACE AN EXIT PARAMETER (PPM) IN ! 822: * ANY PROCEDURE CALL. THE INT ARGUMENT IS A UNIQUE ! 823: * ERROR CODE IN 0 TO 899. ! 824: * THE TEXT SUPPLIED AS THE OTHER OPERAND IS ! 825: * ARBITRARY TEXT IN THE FORTRAN CHARACTER SET AND ! 826: * MAY BE USED IN CONSTRUCTING A FILE OF ERROR ! 827: * MESSAGES FOR DOCUMENTING PURPOSES OR FOR BUILDING ! 828: * A DIRECT ACCESS OR OTHER FILE OF MESSAGES TO BE ! 829: * USED BY THE ERROR HANDLING CODE. ! 830: * IN THE EVENT THAT AN EXI ATTEMPTS ! 831: * TO RETURN CONTROL VIA AN EXIT PARAMETER TO ! 832: * AN ERR, CONTROL IS INSTEAD PASSED TO THE FIRST ! 833: * INSTRUCTION IN THE ERROR SECTION (WHICH FOLLOWS THE ! 834: * PROGRAM SECTION) WITH THE ERROR CODE IN WA. ! 835: * ! 836: * 1.15 ERB INT,TEXT ERROR BRANCH ! 837: * ! 838: * THIS INSTRUCTION RESEMBLES ERR EXCEPT THAT IT MAY ! 839: * OCCUR AT ANY POINT WHERE A BRANCH IS PERMITTED. ! 840: * IT EFFECTS A TRANSFER OF CONTROL TO THE ERROR ! 841: * SECTION WITH THE ERROR CODE IN WA. ! 842: * ! 843: * 1.16 ICV OPN INCREMENT VALUE BY ONE ! 844: * ! 845: * ICV INCREMENTS THE VALUE OF THE OPERAND BY UNITY. ! 846: * IT IS EQUIVALENT TO ADD =UNITY,OPN ! 847: * ! 848: * 1.17 DCV OPN DECREMENT VALUE BY ONE ! 849: * ! 850: * DCV DECREMENTS THE VALUE OF THE OPERAND BY UNITY. ! 851: * IT IS EQUIVALENT TO SUB =UNITY,OPN ! 852: EJC ! 853: * ! 854: * BASIC INSTRUCTIONS (CONTINUED) ! 855: * ! 856: * 1.18 ZER OPN ZEROISE OPN ! 857: * ! 858: * ZER IS EQUIVALENT TO MOV =ZEROE,OPN ! 859: * ! 860: * 1.19 MNZ OPN MOVE NON-ZERO TO OPN ! 861: * ! 862: * ANY NON-ZERO COLLECTABLE VALUE MAY USED, FOR WHICH ! 863: * THE OPCODES BNZ/BZE WILL BRANCH/FAIL TO BRANCH. ! 864: * ! 865: * 1.20 SSL OPW SUBROUTINE STACK LOAD ! 866: * ! 867: * 1.21 SSS OPW SUBROUTINE STACK STORE ! 868: * ! 869: * THIS PAIR OF OPERATIONS IS PROVIDED TO MAKE POSSIBLE ! 870: * THE USE OF A LOCAL STACK TO HOLD SUBROUTINE (S-R) ! 871: * RETURN LINKS FOR N-TYPE PROCEDURES. SSS STORES THE ! 872: * S-R STACK POINTER IN OPW AND SSL LOADS THE S-R ! 873: * STACK POINTER FROM OPW. BY USING SSS IN THE MAIN ! 874: * PROGRAM OR ON ENTRY TO A PROCEDURE WHICH SHOULD ! 875: * REGAIN CONTROL ON OCCURRENCE OF AN ERR OR ERB AND BY ! 876: * USE OF SSL IN THE ERROR PROCESSING SECTIONS THE ! 877: * S-R STACK POINTER CAN BE RESTORED GIVING A LINK ! 878: * STACK CLEANED UP READY FOR RESUMED EXECUTION. ! 879: * THE FORM OF THE LINK STACK POINTER IS UNDEFINED IN ! 880: * MINIMAL (IT IS LIKELY TO BE A PRIVATE REGISTER ! 881: * KNOWN TO THE TRANSLATOR) AND THE ONLY REQUIREMENT ! 882: * IS THAT IT SHOULD FIT INTO A SINGLE FULL WORD. ! 883: * SSL AND SSS ARE NO-OPS IF A PRIVATE LINK STACK IS ! 884: * NOT USED. ! 885: * ! 886: * 1.22 RTN DEFINE START OF ROUTINE ! 887: * ! 888: * A ROUTINE IS A CODE CHUNK USED FOR SIMILAR PURPOSES ! 889: * TO A PROCEDURE. HOWEVER IT IS ENTERED BY ANY TYPE OF ! 890: * CONDITIONAL OR UNCONDITIONAL BRANCH (NOT BY JSR). ON ! 891: * TERMINATION IT PASSES CONTROL BY A BRANCH (OFTEN ! 892: * BRI THROUGH A CODE WORD) OR EVEN PERMITS CONTROL ! 893: * TO DROP THROUGH TO ANOTHER ROUTINE. NO RETURN LINK ! 894: * EXISTS AND THE END OF A ROUTINE IS NOT MARKED BY ! 895: * AN EXPLICIT OPCODE (COMPARE ENP). ! 896: * ALL ROUTINES SHOULD BE NAMED IN SECTION 0 ! 897: * INR STATEMENTS. ! 898: EJC ! 899: * ! 900: * -2- OPERATIONS ON ONE WORD INTEGER VALUES (ADDRESSES) ! 901: * ! 902: * 2.1 ADD OPV,OPN ADDS OPV TO THE VALUE IN OPN AND ! 903: * STORES THE RESULT IN OPN. UNDEFINED ! 904: * IF THE RESULT EXCEEDS CFP$M. ! 905: * ! 906: * 2.2 SUB OPV,OPN SUBTRACTS OPV FROM OPN. STORES THE ! 907: * RESULT IN OPN. UNDEFINED IF THE ! 908: * RESULT IS NEGATIVE. ! 909: * ! 910: * 2.3 ICA OPN INCREMENT ADDRESS IN OPN ! 911: * EQUIVALENT TO ADD *UNITY,OPN ! 912: * ! 913: * 2.4 DCA OPN DECREMENT ADDRESS IN OPN ! 914: * EQUIVALENT TO SUB *UNITY,OPN ! 915: * ! 916: * 2.5 BEQ OPN,OPV,PLBL BRANCH TO PLBL IF OPN EQ OPV ! 917: * 2.6 BNE OPN,OPV,PLBL BRANCH TO PLBL IF OPN NE OPV ! 918: * 2.7 BGT OPN,OPV,PLBL BRANCH TO PLBL IF OPN GT OPV ! 919: * 2.8 BGE OPN,OPV,PLBL BRANCH TO PLBL IF OPN GE OPV ! 920: * 2.9 BLT OPN,OPV,PLBL BRANCH TO PLBL IF OPN LT OPV ! 921: * 2.10 BLE OPN,OPV,PLBL BRANCH TO PLBL IF OPN LE OPV ! 922: * 2.11 BLO OPN,OPV,PLBL EQUIVALENT TO BLT OR BLE ! 923: * 2.12 BHI OPN,OPV,PLBL EQUIVALENT TO BGT OR BGE ! 924: * ! 925: * THE ABOVE INSTRUCTIONS COMPARE TWO ADDRESS ! 926: * VALUES AS UNSIGNED INTEGER VALUES. ! 927: * THE BLO AND BHI INSTRUCTIONS ARE USED IN CASES WHERE ! 928: * THE EQUAL CONDITION EITHER DOES NOT OCCUR OR CAN ! 929: * RESULT EITHER IN A BRANCH OR NO BRANCH. THIS AVOIDS ! 930: * INEFFICIENT TRANSLATIONS IN SOME IMPLEMENTATIONS. ! 931: * ! 932: * 2.13 BNZ OPN,PLBL EQUIVALENT TO BNE OPN,=ZEROE,PLBL ! 933: * ! 934: * 2.14 BZE OPN,PLBL EQUIVALENT TO BEQ OPN,=ZEROE,PLBL ! 935: * ! 936: * ! 937: * 2.15 LCT W,OPV LOAD COUNTER FOR BCT ! 938: * ! 939: * LCT LOADS A COUNTER VALUE FOR USE WITH THE BCT ! 940: * INSTRUCTION. THE VALUE IN OPV IS THE NUMBER OF LOOPS ! 941: * TO BE EXECUTED. THE VALUE IN W AFTER THIS OPERATION ! 942: * IS AN UNDEFINED ONE WORD INTEGER QUANTITY. ! 943: * ! 944: * 2.16 BCT W,PLBL BRANCH AND COUNT ! 945: * ! 946: * BCT USES THE COUNTER VALUE IN W TO BRANCH THE ! 947: * REQUIRED NUMBER OF TIMES AND THEN FINALLY TO FALL ! 948: * THROUGH TO THE NEXT INSTRUCTION. BCT CAN ONLY BE ! 949: * USED FOLLOWING AN APPROPRIATE LCT INSTRUCTION. ! 950: * THE VALUE IN W AFTER EXECUTION OF BCT IS UNDEFINED. ! 951: * ! 952: * 2.17 AOV OPV,OPN,PLBL ADD WITH OVERFLOW TEST ! 953: * ! 954: * ADDS OPV TO THE VALUE IN OPN AND STORES RESULT IN ! 955: * OPN. BRANCHES TO PLBL IF RESULT EXCEEDS CFP$M ! 956: * WITH RESULT IN OPN UNDEFINED. CF. ADD. ! 957: EJC ! 958: * ! 959: * -3- OPERATIONS ON THE CODE POINTER REGISTER (CP) ! 960: * ! 961: * THE CODE POINTER REGISTER PROVIDES A PSUEDO ! 962: * INSTRUCTION COUNTER FOR USE IN AN INTERPRETOR. IT ! 963: * MAY BE IMPLEMENTED AS A REAL REGISTER OR AS A ! 964: * MEMORY LOCATION, BUT IN EITHER CASE IT IS SEPARATE ! 965: * FROM ANY OTHER REGISTER. THE VALUE IN THE CODE ! 966: * POINTER REGISTER IS ALWAYS A WORD ADDRESS (I.E. ! 967: * A ONE WORD INTEGER WHICH IS A MULTIPLE OF CFP$B). ! 968: * ! 969: * 3.1 LCP REG LOAD CODE POINTER REGISTER ! 970: * THIS INSTRUCTION CAUSES THE CODE ! 971: * POINTER REGISTER TO BE SET FROM ! 972: * THE VALUE IN REG WHICH IS UNCHANGED ! 973: * ! 974: * 3.2 SCP REG STORE CODE POINTER REGISTER ! 975: * THIS INSTRUCTION LOADS THE CURRENT ! 976: * VALUE IN THE CODE POINTER REGISTER ! 977: * INTO REG. (CP) IS UNCHANGED. ! 978: * ! 979: * 3.3 LCW REG LOAD NEXT CODE WORD ! 980: * THIS INSTRUCTION CAUSES THE WORD ! 981: * POINTED TO BY CP TO BE LOADED INTO ! 982: * THE INDICATED REG. THE VALUE IN CP ! 983: * IS THEN INCREMENTED BY ONE WORD. ! 984: * EXECUTION OF LCW MAY DESTROY XL. ! 985: * ! 986: * 3.4 ICP INCREMENT CP BY ONE WORD ! 987: * ! 988: * ON MACHINES WITH MORE THAN THREE INDEX REGISTERS, ! 989: * CP CAN BE TREATED SIMPLY AS AN INDEX REGISTER. ! 990: * IN THIS CASE, THE FOLLOWING EQUIVALENCES APPLY. ! 991: * ! 992: * LCP REG IS LIKE MOV REG,CP ! 993: * SCP REG IS LIKE MOV CP,REG ! 994: * LCW REG IS LIKE MOV (CP)+,REG ! 995: * ICP IS LIKE ICA CP ! 996: * ! 997: * SINCE LCW IS ALLOWED TO DESTROY XL, THE FOLLOWING ! 998: * IMPLEMENTATION USING A WORK LOCATION CP$$$ CAN ! 999: * ALSO BE USED. ! 1000: * ! 1001: * LCP REG MOV REG,CP$$$ ! 1002: * ! 1003: * SCP REG MOV CP$$$,REG ! 1004: * ! 1005: * LCW REG MOV CP$$$,XL ! 1006: * MOV (XL)+,REG ! 1007: * MOV XL,CP$$$ ! 1008: * ! 1009: * ICP ICA CP$$$ ! 1010: EJC ! 1011: * ! 1012: * -4- OPERATIONS ON SIGNED INTEGER VALUES ! 1013: * ! 1014: * 4.1 LDI OPS LOAD INTEGER ACCUMULATOR FROM OPS ! 1015: * 4.2 ADI OPS ADD OPS TO INTEGER ACCUMULATOR ! 1016: * 4.3 MLI OPS MULTIPLY INTEGER ACCUMULATOR BY OPS ! 1017: * 4.4 SBI OPS SUBTRACT OPS FROM INT ACCUMULATOR ! 1018: * 4.5 DVI OPS DIVIDE INTEGER ACCUMULATOR BY OPS ! 1019: * 4.6 RMI OPS SET INT ACCUM TO MOD(INTACC,OPS) ! 1020: * 4.7 STI OPS STORE INTEGER ACCUMULATOR AT OPS ! 1021: * 4.8 NGI NEGATE THE VALUE IN THE INTEGER ! 1022: * ACCUMULATOR (CHANGE ITS SIGN) ! 1023: * ! 1024: * THE EQUATION SATISFIED BY OPERANDS AND RESULTS OF ! 1025: * DVI AND RMI IS ! 1026: * DIV = QOT * OPS + REM WHERE ! 1027: * DIV = DIVIDEND IN INTEGER ACCUMULATOR ! 1028: * QOT = QUOTIENT LEFT IN IA BY DIV ! 1029: * OPS = THE DIVISOR ! 1030: * REM = REMAINDER LEFT IN IA BY RMI ! 1031: * THE SIGN OF THE RESULT OF DVI IS + IF (IA) AND (OPS) ! 1032: * HAVE THE SAME SIGN AND IS - IF THEY HAVE OPPOSITE ! 1033: * SIGNS. THE SIGN OF (IA) IS ALWAYS USED AS THE SIGN ! 1034: * OF THE RESULT OF REM. ! 1035: * ASSUMING IN EACH CASE THAT IA CONTAINS THE NUMBER ! 1036: * SPECIFIED IN PARENTHESES AND THAT SEVEN AND MSEVN ! 1037: * HOLD +7 AND -7 RESP. THE ALGORITHM IS ILLUSTRATED ! 1038: * BELOW. ! 1039: * (IA = 13) ! 1040: * DVI SEVEN IA = 1 ! 1041: * RMI SEVEN IA = 6 ! 1042: * DVI MSEVN IA = -1 ! 1043: * RMI MSEVN IA = 6 ! 1044: * (IA = -13) ! 1045: * DVI SEVEN IA = -1 ! 1046: * RMI SEVEN IA = -6 ! 1047: * DVI MSEVN IA = 1 ! 1048: * RMI MSEVN IA = -6 ! 1049: EJC ! 1050: * ! 1051: * THE ABOVE INSTRUCTIONS OPERATE ON A FULL RANGE OF ! 1052: * SIGNED INTEGER VALUES. WITH THE EXCEPTION OF LDI AND ! 1053: * STI, THESE INSTRUCTIONS MAY CAUSE INTEGER OVERFLOW ! 1054: * BY ATTEMPTING TO PRODUCE AN UNDEFINED OR OUT OF ! 1055: * RANGE RESULT IN WHICH CASE INTEGER OVERFLOW IS SET, ! 1056: * THE RESULT IN (IA) IS UNDEFINED AND THE FOLLOWING ! 1057: * INSTRUCTION MUST BE IOV OR INO. ! 1058: * PARTICULAR CARE MAY BE NEEDED ON TARGET MACHINES ! 1059: * HAVING DISTINCT OVERFLOW AND DIVIDE BY ZERO ! 1060: * CONDITIONS. ! 1061: * ! 1062: * 4.9 INO PLBL JUMP TO PLBL IF NO INTEGER OVERFLOW ! 1063: * 4.10 IOV PLBL JUMP TO PLBL IF INTEGER OVERFLOW ! 1064: * ! 1065: * THESE INSTRUCTIONS CAN ONLY OCCUR IMMEDIATELY ! 1066: * FOLLOWING AN INSTRUCTION WHICH CAN CAUSE INTEGER ! 1067: * OVERFLOW (ADI, SBI, MLI, DVI, RMI, NGI) AND ! 1068: * TEST THE RESULT OF THE PRECEDING INSTRUCTION. ! 1069: * IOV AND INO MAY NOT HAVE LABELS. ! 1070: * ! 1071: * 4.11 IEQ PLBL JUMP TO PLBL IF (IA) EQ 0 ! 1072: * 4.12 IGE PLBL JUMP TO PLBL IF (IA) GE 0 ! 1073: * 4.13 IGT PLBL JUMP TO PLBL IF (IA) GT 0 ! 1074: * 4.14 ILE PLBL JUMP TO PLBL IF (IA) LE 0 ! 1075: * 4.15 ILT PLBL JUMP TO PLBL IF (IA) LT 0 ! 1076: * 4.16 INE PLBL JUMP TO PLBL IF (IA) NE 0 ! 1077: * ! 1078: * THE ABOVE CONDITIONAL JUMP INSTRUCTIONS DO ! 1079: * NOT CHANGE THE CONTENTS OF THE ACCUMULATOR. ! 1080: * ON A ONES COMPLEMENT MACHINE, IT IS PERMISSIBLE TO ! 1081: * PRODUCE NEGATIVE ZERO IN IA PROVIDED THESE ! 1082: * INSTRUCTIONS OPERATE CORRECTLY WITH SUCH A VALUE. ! 1083: EJC ! 1084: * ! 1085: * -5- OPERATIONS ON REAL VALUES ! 1086: * ! 1087: * 5.1 LDR OPS LOAD REAL ACCUMULATOR FROM OPS ! 1088: * 5.2 STR OPS STORE REAL ACCUMULATOR AT OPS ! 1089: * 5.3 ADR OPS ADD OPS TO REAL ACCUMULATOR ! 1090: * 5.4 SBR OPS SUBTRACT OPS FROM REAL ACCUMULATOR ! 1091: * 5.5 MLR OPS MULTIPLY REAL ACCUMULATOR BY OPS ! 1092: * 5.6 DVR OPS DIVIDE REAL ACCUMULATOR BY OPS ! 1093: * ! 1094: * IF THE RESULT OF ANY OF THE ABOVE OPERATIONS CAUSES ! 1095: * UNDERFLOW, THE RESULT YIELDED IS 0.0. ! 1096: * ! 1097: * IF THE RESULT OF ANY OF THE ABOVE OPERATIONS IS ! 1098: * UNDEFINED OR OUT OF RANGE, REAL OVERFLOW IS SET, ! 1099: * THE CONTENTS OF (RA) ARE UNDEFINED AND THE FOLLOWING ! 1100: * INSTRUCTION MUST BE EITHER ROV OR RNO. ! 1101: * PARTICULAR CARE MAY BE NEEDED ON TARGET MACHINES ! 1102: * HAVING DISTINCT OVERFLOW AND DIVIDE BY ZERO ! 1103: * CONDITIONS. ! 1104: * ! 1105: * 5.7 ROV PLBL JUMP TO PLBL IF REAL OVERFLOW ! 1106: * 5.8 RNO PLBL JUMP TO PLBL IF NO REAL OVERFLOW ! 1107: * ! 1108: * THESE INSTRUCTIONS CAN ONLY OCCUR IMMEDIATELY ! 1109: * FOLLOWING AN INSTRUCTION WHICH CAN CAUSE REAL ! 1110: * OVERFLOW (ADR,SBR,MLR,DVR). ! 1111: * ! 1112: * 5.9 NGR NEGATE REAL ACCUM (CHANGE SIGN) ! 1113: * ! 1114: * 5.10 REQ PLBL JUMP TO PLBL IF (RA) EQ 0.0 ! 1115: * 5.11 RGE PLBL JUMP TO PLBL IF (RA) GE 0.0 ! 1116: * 5.12 RGT PLBL JUMP TO PLBL IF (RA) GT 0.0 ! 1117: * 5.13 RLE PLBL JUMP TO PLBL IF (RA) LE 0.0 ! 1118: * 5.14 RLT PLBL JUMP TO PLBL IF (RA) LT 0.0 ! 1119: * 5.15 RNE PLBL JUMP TO PLBL IF (RA) NE 0.0 ! 1120: * ! 1121: * THE ABOVE CONDITIONAL INSTRUCTIONS DO NOT AFFECT ! 1122: * THE VALUE STORED IN THE REAL ACCUMULATOR. ! 1123: * ON A ONES COMPLEMENT MACHINE, IT IS PERMISSIBLE TO ! 1124: * PRODUCE NEGATIVE ZERO IN RA PROVIDED THESE ! 1125: * INSTRUCTIONS OPERATE CORRECTLY WITH SUCH A VALUE. ! 1126: EJC ! 1127: * ! 1128: * -6- OPERATIONS ON CHARACTER VALUES ! 1129: * ! 1130: * CHARACTER OPERATIONS EMPLOY THE CONCEPT OF A ! 1131: * CHARACTER POINTER WHICH USES EITHER ! 1132: * INDEX REGISTER XR OR XL (NOT XS). ! 1133: * ! 1134: * A CHARACTER POINTER POINTS TO A SPECIFIC CHARACTER ! 1135: * IN A STRING OF CHARACTERS STORED CFP$C CHARS TO A ! 1136: * WORD. THE ONLY OPERATIONS PERMITTED ON A CHARACTER ! 1137: * POINTER ARE LCH AND SCH. IN PARTICULAR, A CHARACTER ! 1138: * POINTER MAY NOT EVEN BE MOVED WITH MOV. ! 1139: * ! 1140: * RESTRICTION 1. ! 1141: * -------------- ! 1142: * IT IS IMPORTANT WHEN CODING IN MINIMAL TO ENSURE ! 1143: * THAT NO ACTION OCCURRING BETWEEN THE INITIAL USE OF ! 1144: * PLC OR PSC AND THE EVENTUAL CLEARING OF XL OR XR ON ! 1145: * COMPLETION OF CHARACTER OPERATIONS CAN INITIATE A ! 1146: * GARBAGE COLLECTION. THE LATTER OF COURSE COULD CAUSE ! 1147: * THE ADDRESSED CHARACTERS TO BE MOVED LEAVING THE ! 1148: * CHARACTER POINTERS POINTING TO RUBBISH. ! 1149: * ! 1150: * RESTRICTION 2. ! 1151: * -------------- ! 1152: * A FURTHER RESTRICTION TO BE OBSERVED IN CODE ! 1153: * HANDLING CHARACTER STRINGS, IS THAT STRINGS BUILT ! 1154: * DYNAMICALLY SHOULD BE RIGHT PADDED WITH ZERO ! 1155: * CHARACTERS TO A FULL WORD BOUNDARY TO PERMIT EASY ! 1156: * HASHING AND USE OF CEQ OR CNE IN TESTING STRINGS ! 1157: * FOR EQUALITY. ! 1158: * ! 1159: * 6.1 PLC X,OPV PREPARE CH PTR FOR LCH,CMC,MVC,TRC ! 1160: * ! 1161: * 6.2 PSC X,OPV PREPARE CHAR. PTR FOR SCH,MVC. ! 1162: * ! 1163: * OPV CAN BE OMITTED IF IT IS ZERO. ! 1164: * THE CHAR. INITIALLY ADDRESSED IS DETERMINED BY THE ! 1165: * WORD ADDRESS IN X AND THE INTEGER OFFSET OPV. ! 1166: * THERE IS AN AUTOMATIC IMPLIED OFFSET OF CFP$F BYTES. ! 1167: * CFP$F IS USED TO FORMALLY INTRODUCE INTO MINIMAL A ! 1168: * VALUE NEEDED IN TRANSLATING THESE OPCODES WHICH, ! 1169: * SINCE MINIMAL ITSELF DOES NOT PRESCRIBE A STRING ! 1170: * STRUCTURE IN DETAIL, DEPENDS ON THE CHOICE OF A DATA ! 1171: * STRUCTURE FOR STRINGS IN THE MINIMAL PROGRAM. ! 1172: * E.G. IF CFP$B = CFP$C = 3, CFP$F = 6, NUM01 = 1, XL ! 1173: * POINTS TO A SERIES OF 4 WORDS, ABC/DEF/GHI/JKL, THEN ! 1174: * PLC XL,=NUM01 ! 1175: * POINTS TO H. ! 1176: EJC ! 1177: * ! 1178: * -6- OPERATIONS ON CHARACTER VALUES (CONTINUED) ! 1179: * ! 1180: * 6.3 LCH REG,OPC LOAD CHARACTER INTO REG ! 1181: * ! 1182: * 6.4 SCH REG,OPC STORE CHARACTER FROM REG ! 1183: * ! 1184: * THESE OPERATIONS ARE DEFINED SUCH THAT THE CHARACTER ! 1185: * IS RIGHT JUSTIFIED IN REGISTER REG WITH ZERO BITS TO ! 1186: * THE LEFT. AFTER LCH FOR EXAMPLE, IT IS LEGITIMATE ! 1187: * TO REGARD REG AS CONTAINING THE ORDINAL INTEGER ! 1188: * CORRESPONDING TO THE CHARACTER. ! 1189: * ! 1190: * OPC IS ONE OF THE FOLLOWING THREE POSSIBILITIES. ! 1191: * ! 1192: * (X) THE CHARACTER POINTED TO BY THE ! 1193: * CHARACTER POINTER IN X. THE ! 1194: * CHARACTER POINTER IS NOT CHANGED. ! 1195: * ! 1196: * (X)+ SAME CHARACTER AS (X) BUT THE ! 1197: * CHARACTER POINTER IS INCREMENTED ! 1198: * TO POINT TO THE NEXT CHARACTER ! 1199: * FOLLOWING EXECUTION. ! 1200: * ! 1201: * -(X) THE CHARACTER POINTER IS DECRE- ! 1202: * MENTED BEFORE ACCESSING THE ! 1203: * CHARACTER SO THAT THE PREVIOUS ! 1204: * CHARACTER IS REFERENCED. ! 1205: * ! 1206: * 6.5 CSC X COMPLETE STORE CHARACTERS ! 1207: * ! 1208: * THIS INSTRUCTION MARKS COMPLETION OF A ! 1209: * PSC,SCH,SCH,...,SCH SEQUENCE INITIATED BY ! 1210: * A PSC X INSTRUCTION. NO MORE SCH INSTRUCTIONS ! 1211: * USING X SHOULD BE OBEYED UNTIL ANOTHER PSC ! 1212: * IS OBEYED. THIS MAKES BUFFERING OF SCH CHARS ! 1213: * FEASIBLE ON MACHINES LACKING CHARACTER ORDERS. ! 1214: * IF CSC IS NOT A NO-OP, IT MUST OBSERVE RESTRICTION 2 ! 1215: * ! 1216: * THE FOLLOWING INSTRUCTIONS ARE USED TO COMPARE ! 1217: * TWO WORDS CONTAINING CFP$C CHARACTERS. ! 1218: * COMPARISONS DISTINCT FROM BEQ,BNE ARE PROVIDED AS ! 1219: * ON SOME TARGET MACHINES, THE POSSIBILITY OF THE SIGN ! 1220: * BIT BEING SET MAY REQUIRE SPECIAL ACTION. ! 1221: * NOTE THAT RESTRICTION 2 ABOVE, EASES USE OF THESE ! 1222: * ORDERS IN TESTING COMPLETE STRINGS FOR EQUALITY, ! 1223: * SINCE WHOLE WORD TESTS ARE POSSIBLE. ! 1224: * ! 1225: * 6.6 CEQ OPW,OPW,PLBL JUMP TO PLBL IF OPW EQ OPW ! 1226: * 6.7 CNE OPW,OPW,PLBL JUMP TO PLBL IF OPW NE OPW ! 1227: EJC ! 1228: * ! 1229: * -6- OPERATIONS ON CHARACTER VALUES (CONTINUED) ! 1230: * ! 1231: * 6.8 CMC PLBL,PLBL COMPARE CHARACTERS ! 1232: * ! 1233: * CMC IS USED TO COMPARE TWO CHARACTER STRINGS. BEFORE ! 1234: * EXECUTING CMC, REGISTERS ARE SET UP AS FOLLOWS. ! 1235: * (XL) CHARACTER PTR FOR FIRST STRING ! 1236: * (XR) CHARACTER POINTER FOR SECOND STRING ! 1237: * (WA) CHARACTER COUNT (MUST BE .GT. ZERO) ! 1238: * XL AND XR SHOULD HAVE BEEN PREPARED BY PLC. ! 1239: * CONTROL PASSES TO FIRST PLBL IF THE FIRST STRING ! 1240: * IS LEXICALLY LESS THAN THE SECOND STRING, AND TO ! 1241: * THE SECOND PLBL IF THE FIRST STRING IS LEXICALLY ! 1242: * GREATER. CONTROL PASSES TO THE FOLLOWING INSTRUCTION ! 1243: * IF THE STRINGS ARE IDENTICAL. AFTER EXECUTING THIS ! 1244: * INSTRUCTION, THE VALUES OF XR AND XL ARE SET TO ZERO ! 1245: * AND THE VALUE IN (WA) IS UNDEFINED. ! 1246: * ARGUMENTS TO CMC MAY BE COMPLETE OR PARTIAL ! 1247: * STRINGS, SO MAKING OPTIMISATION TO USE WHOLE WORD ! 1248: * COMPARISONS DIFFICULT (DEPENDENT IN GENERAL ON ! 1249: * SHIFTS AND MASKING). ! 1250: * ! 1251: * 6.9 TRC TRANSLATE CHARACTERS ! 1252: * ! 1253: * TRC IS USED TO TRANSLATE A CHARACTER STRING USING A ! 1254: * SUPPLIED TRANSLATION TABLE. BEFORE EXECUTING TRC THE ! 1255: * REGISTERS ARE SET AS FOLLOWS. ! 1256: * (XL) CHAR PTR TO STRING TO BE TRANSLATED ! 1257: * (XR) CHAR PTR TO TRANSLATE TABLE ! 1258: * (WA) LENGTH OF STRING TO BE TRANSLATED ! 1259: * XL AND XR SHOULD HAVE BEEN PREPARED BY PLC. ! 1260: * THE TRANSLATE TABLE CONSISTS OF CFP$A CONTIGUOUS ! 1261: * CHARACTERS GIVING THE TRANSLATIONS OF THE CFP$A ! 1262: * CHARACTERS IN THE ALPHABET. ON COMPLETION, (XR) AND ! 1263: * (XL) ARE SET TO ZERO AND (WA) IS UNDEFINED. ! 1264: EJC ! 1265: * ! 1266: * -7- OPERATIONS ON BIT STRING VALUES ! 1267: * ! 1268: * 7.1 ANB OPW,W AND BIT STRING VALUES ! 1269: * 7.2 ORB OPW,W OR BIT STRING VALUES ! 1270: * 7.3 XOB OPW,W EXCLUSIVE OR BIT STRING VALUES ! 1271: * ! 1272: * IN THE ABOVE OPERATIONS, THE LOGICAL CONNECTIVE IS ! 1273: * APPLIED SEPARATELY TO EACH OF THE CFP$N BITS. ! 1274: * THE RESULT IS STORED IN THE SECOND OPERAND LOCATION. ! 1275: * ! 1276: * 7.4 CMB W COMPLEMENT ALL BITS IN OPW ! 1277: * ! 1278: * 7.5 RSH W,VAL RIGHT SHIFT BY VAL BITS ! 1279: * 7.6 LSH W,VAL LEFT SHIFT BY VAL BITS ! 1280: * 7.7 RSX W,(X) RIGHT SHIFT W NUMBER OF BITS IN X ! 1281: * 7.8 LSX W,(X) LEFT SHIFT W NUMBER OF BITS IN X ! 1282: * ! 1283: * THE ABOVE SHIFTS ARE LOGICAL SHIFTS IN WHICH BITS ! 1284: * SHIFTED OUT ARE LOST AND ZERO BITS SUPPLIED AS ! 1285: * REQUIRED. THE SHIFT COUNT IS IN THE RANGE 0-CFP$N. ! 1286: * ! 1287: * 7.9 NZB W,PLBL JUMP TO PLBL IF W IS NOT ! 1288: * ALL ZERO BITS. ! 1289: * ! 1290: * 7.10 ZRB W,PLBL JUMP TO PLBL IF W IS ALL ZERO BITS ! 1291: * ! 1292: * 7.11 ZGB OPN ZEROISE GARBAGE BITS ! 1293: * ! 1294: * OPN CONTAINS A BIT STRING REPRESENTING A WORD ! 1295: * OF CHARACTERS FROM A STRING OR SOME FUNCTION ! 1296: * FORMED FROM SUCH CHARACTERS (E.G. AS A RESULT OF ! 1297: * HASHING). ON A MACHINE WHERE THE WORD SIZE IS NOT A ! 1298: * MULTIPLE OF THE CHARACTER SIZE, SOME BITS IN REG MAY ! 1299: * BE UNDEFINED. THIS OPCODE REPLACES SUCH BITS BY THE ! 1300: * ZERO BIT. ZGB IS A NO-OP IF THE WORD SIZE IS A ! 1301: * MULTIPLE OF THE CHARACTER SIZE. ! 1302: EJC ! 1303: * ! 1304: * -8- CONVERSION INSTRUCTIONS ! 1305: * ! 1306: * THE FOLLOWING INSTRUCTIONS PROVIDE FOR CONVERSION ! 1307: * BETWEEN LENGTHS IN BYTES AND LENGTHS IN WORDS. ! 1308: * ! 1309: * 8.1 WTB REG CONVERT REG FROM WORDS TO BYTES. ! 1310: * THAT IS, MULTIPLY BY CFP$B. THIS IS ! 1311: * A NO-OP IF CFP$B IS ONE. ! 1312: * ! 1313: * 8.2 BTW REG CONVERT REG FROM BYTES TO WORDS ! 1314: * BY DIVIDING REG BY CFP$B DISCARDING ! 1315: * THE FRACTION. NO-OP IF CFP$B IS ONE ! 1316: * ! 1317: * THE FOLLOWING INSTRUCTIONS PROVIDE FOR CONVERSION ! 1318: * OF ONE WORD INTEGER VALUES (ADDRESSES) TO AND ! 1319: * FROM THE FULL SIGNED INTEGER FORMAT. ! 1320: * ! 1321: * 8.3 MTI OPN THE VALUE OF OPN (AN ADDRESS) ! 1322: * IS MOVED AS A POSITIVE INTEGER ! 1323: * TO THE INTEGER ACCUMULATOR. ! 1324: * ! 1325: * 8.4 MFI OPN,PLBL THE VALUE CURRENTLY STORED IN THE ! 1326: * INTEGER ACCUMULATOR IS MOVED ! 1327: * TO OPN AS AN ADDRESS IF IT IS IN ! 1328: * THE RANGE 0 TO CFP$M INCLUSIVE. ! 1329: * IF THE ACCUMULATOR VALUE IS ! 1330: * OUTSIDE THIS RANGE, THEN THE RESULT ! 1331: * IN OPN IS UNDEFINED AND CONTROL IS ! 1332: * PASSED TO PLBL. MFI DESTROYS THE ! 1333: * VALUE OF (IA) WHETHER OR NOT ! 1334: * INTEGER OVERFLOW IS SIGNALLED. ! 1335: * PLBL MAY BE OMITTED IF OVERFLOW ! 1336: * IS IMPOSSIBLE. ! 1337: * ! 1338: * THE FOLLOWING INSTRUCTIONS PROVIDE FOR CONVERSION ! 1339: * BETWEEN REAL VALUES AND INTEGER VALUES. ! 1340: * ! 1341: * 8.5 ITR CONVERT INTEGER VALUE IN INTEGER ! 1342: * ACCUMULATOR TO REAL AND STORE IN ! 1343: * REAL ACCUMULATOR (MAY LOSE ! 1344: * PRECISION IN SOME CASES) ! 1345: * ! 1346: * 8.6 RTI PLBL CONVERT THE REAL VALUE IN RA TO ! 1347: * AN INTEGER AND PLACE RESULT IN IA. ! 1348: * CONVERSION IS BY TRUNCATION OF THE ! 1349: * FRACTION - NO ROUNDING OCCURS. ! 1350: * JUMP TO PLBL IF OUT OF RANGE. (RA) ! 1351: * IS NOT CHANGED IN EITHER CASE. ! 1352: * PLBL MAY BE OMITTED IF OVERFLOW ! 1353: * IS IMPOSSIBLE. ! 1354: EJC ! 1355: * ! 1356: * -8- CONVERSION INSTRUCTIONS (CONTINUED) ! 1357: * ! 1358: * THE FOLLOWING INSTRUCTIONS PROVIDE FOR COMPUTING ! 1359: * THE LENGTH OF STORAGE REQUIRED FOR A TEXT STRING. ! 1360: * ! 1361: * 8.7 CTW W,VAL THIS INSTRUCTION COMPUTES THE SUM ! 1362: * (NUMBER OF WORDS REQUIRED TO STORE ! 1363: * W CHARACTERS) + (VAL). THE SUM ! 1364: * IS STORED IN W. ! 1365: * FOR EXAMPLE, IF CFP$C IS 5, AND WA ! 1366: * CONTAINS 32, THEN CTW WA,2 ! 1367: * GIVES A RESULT OF 9 IN WA. ! 1368: * ! 1369: * 8.8 CTB W,VAL CTB IS EXACTLY LIKE CTW EXCEPT THAT ! 1370: * THE RESULT IS IN BYTES. IT HAS THE ! 1371: * SAME EFFECT AS CTW W,VAL WTB W ! 1372: * ! 1373: * THE FOLLOWING INSTRUCTIONS PROVIDE FOR CONVERSION ! 1374: * FROM INTEGERS TO AND FROM NUMERIC DIGIT CHARACTERS ! 1375: * FOR USE IN NUMERIC CONVERSION ROUTINES. THEY EMPLOY ! 1376: * NEGATIVE INTEGER VALUES TO ALLOW FOR PROPER ! 1377: * CONVERSION OF NUMBERS WHICH CANNOT BE COMPLEMENTED. ! 1378: * ! 1379: * 8.9 CVM PLBL CONVERT BY MULTIPLICATION ! 1380: * ! 1381: * THE INTEGER ACCUMULATOR, WHICH IS ZERO OR NEGATIVE, ! 1382: * IS MULTIPLIED BY 10. WB CONTAINS THE CHARACTER ! 1383: * CODE FOR A DIGIT. THE VALUE OF THIS DIGIT IS THEN ! 1384: * SUBTRACTED FROM THE RESULT. IF THE RESULT IS OUT OF ! 1385: * RANGE, THEN CONTROL IS PASSED TO PLBL WITH THE ! 1386: * RESULT IN (IA) UNDEFINED. EXECUTION OF CVM LEAVES ! 1387: * THE RESULT IN (WB) UNDEFINED. ! 1388: * ! 1389: * 8.10 CVD CONVERT BY DIVISION ! 1390: * ! 1391: * THE INTEGER ACCUMULATOR, WHICH IS ZERO OR NEGATIVE, ! 1392: * IS DIVIDED BY 10. THE QUOTIENT (ZERO OR NEGATIVE) ! 1393: * IS REPLACED IN THE ACCUMULATOR. THE REMAINDER IS ! 1394: * CONVERTED TO THE CHARACTER CODE OF A DIGIT AND ! 1395: * PLACED IN WA. FOR EXAMPLE, AN OPERAND OF -523 GIVES ! 1396: * A QUOTIENT OF -52 AND A REMAINDER IN WA OF CH$D3. ! 1397: EJC ! 1398: * ! 1399: * -9- BLOCK MOVE INSTRUCTIONS ! 1400: * ! 1401: * THE FOLLOWING INSTRUCTIONS ARE USED FOR TRANSFERRING ! 1402: * DATA FROM ONE AREA OF MEMORY TO ANOTHER IN BLOCKS. ! 1403: * THEY CAN BE IMPLEMENTED WITH THE INDICATED SERIES OF ! 1404: * OTHER MACRO-INSTRUCTIONS, BUT MORE EFFICIENT IMPLE- ! 1405: * MENTATIONS WILL BE POSSSIBLE ON MOST MACHINES. ! 1406: * ! 1407: * 9.1 MVC MOVE CHARACTERS ! 1408: * ! 1409: * BEFORE OBEYING THIS ORDER WA,XL,XR SHOLD HAVE BEEN ! 1410: * SET UP, THE LATTER TWO BY PLC, PSC RESP. ! 1411: * MVC IS EQUIVALENT TO THE SEQUENCE ! 1412: * ! 1413: * MOV WB,DUMPB ! 1414: * LCT WA,WA ! 1415: * LOOPC LCH WB,(XL)+ ! 1416: * SCH WB,(XR)+ ! 1417: * BCT WA,LOOPC ! 1418: * CSC XR ! 1419: * MOV DUMPB,WB ! 1420: * ! 1421: * THE CHARACTER POINTERS ARE BUMPED AS INDICATED ! 1422: * AND THE FINAL VALUE OF WA IS UNDEFINED. ! 1423: * ! 1424: * 9.2 MVW MOVE WORDS ! 1425: * ! 1426: * MVW IS EQUIVALENT TO THE SEQUENCE ! 1427: * ! 1428: * LOOPW MOV (XL)+,(XR)+ ! 1429: * DCA WA WA = BYTES TO MOVE ! 1430: * BNZ WA,LOOPW ! 1431: * ! 1432: * NOTE THAT THIS IMPLIES THAT THE VALUE IN WA IS THE ! 1433: * LENGTH IN BYTES WHICH IS A MULTIPLE OF CFP$B. ! 1434: * THE INITIAL ADDRESSES IN XR,XL ARE WORD ADDRESSES. ! 1435: * AS INDICATED, THE FINAL XR,XL VALUES POINT PAST THE ! 1436: * NEW AND OLD REGIONS OF MEMORY RESPECTIVELY. ! 1437: * THE FINAL VALUE OF WA IS UNDEFINED. ! 1438: * WA,XL,XR MUST BE SET UP BEFORE OBEYING MVW. ! 1439: * ! 1440: * 9.3 MWB MOVE WORDS BACKWARDS ! 1441: * ! 1442: * MWB IS EQUIVALENT TO THE SEQUENCE ! 1443: * ! 1444: * LOOPB MOV -(XL),-(XR) ! 1445: * DCA WA WA = BYTES TO MOVE ! 1446: * BNZ WA,LOOPB ! 1447: * ! 1448: * THERE IS A REQUIREMENT THAT THE INITIAL VALUE IN XL ! 1449: * BE AT LEAST 256 LESS THAN THE VALUE IN XR. THIS ! 1450: * ALLOWS AN IMPLEMENTATION IN WHICH CHUNKS OF 256 ! 1451: * BYTES ARE MOVED FORWARD (IBM 360, ICL 1900). ! 1452: * THE FINAL VALUE OF WA IS UNDEFINED. ! 1453: * WA,XL,XR MUST BE SET UP BEFORE OBEYING MWB. ! 1454: EJC ! 1455: * ! 1456: * -10- OPERATIONS CONNECTED WITH THE STACK ! 1457: * ! 1458: * THE STACK IS AN AREA IN MEMORY WHICH IS DEDICATED FOR USE ! 1459: * IN CONJUNCTION WITH THE STACK POINTER REGISTER (XS). AS ! 1460: * PREVIOUSLY DESCRIBED, IT IS USED BY THE JSR AND EXI ! 1461: * INSTRUCTIONS AND MAY BE USED FOR STORAGE OF ANY OTHER ! 1462: * DATA AS REQUIRED. ! 1463: * ! 1464: * THE STACK BUILDS EITHER WAY IN MEMORY AND AN IMPORTANT ! 1465: * RESTRICTION IS THAT THE VALUE IN (XS) MUST BE THE ADDRESS ! 1466: * OF THE STACK FRONT AT ALL TIMES SINCE ! 1467: * SOME IMPLEMENTATIONS MAY RANDOMLY DESTROY STACK LOCATIONS ! 1468: * BEYOND (XS). ! 1469: * ! 1470: * THE STARTING STACK BASE ADDRESS IS PASSED ! 1471: * IN (XS) AT THE START OF EXECUTION. DURING EXECUTION IT ! 1472: * IS NECESSARY TO MAKE SURE THAT THE STACK DOES NOT ! 1473: * OVERFLOW. THIS IS ACHIEVED BY EXECUTING THE FOLLOWING ! 1474: * INSTRUCTION PERIODICALLY. ! 1475: * ! 1476: * 10.1 CHK CHECK STACK OVERFLOW ! 1477: * ! 1478: * AFTER SUCCESSFULLY EXECUTING CHK, IT IS PERMISSIBLE TO ! 1479: * USE UP TO 100 ADDITIONAL WORDS BEFORE ISSUING ANOTHER CHK ! 1480: * THUS CHK NEED NOT BE ISSUED EVERY TIME THE STACK IS ! 1481: * EXPANDED. IN SOME IMPLEMENTATIONS, THE CHECKING MAY BE ! 1482: * AUTOMATIC AND CHK WILL HAVE NO EFFECT. FOLLOWING THE ! 1483: * ABOVE RULE MAKES SURE THAT THE PROGRAM WILL OPERATE ! 1484: * CORRECTLY IN IMPLEMENTATIONS WITH NO AUTOMATIC CHECK. ! 1485: * ! 1486: * IF STACK OVERFLOW OCCURS (DETECTED EITHER AUTOMATICALLY ! 1487: * OR BY A CHK INSTRUCTION), THEN CONTROL IS PASSED TO THE ! 1488: * STACK OVERFLOW SECTION (SEE PROGRAM FORM). NOTE THAT THIS ! 1489: * TRANSFER MAY TAKE PLACE FOLLOWING ANY INSTRUCTION WHICH ! 1490: * STORES DATA AT A NEW LOCATION ON THE STACK. ! 1491: * AFTER STACK OVERFLOW, STACK IS ARBITRARILY POPPED ! 1492: * TO GIVE SOME SPACE IN WHICH THE ERROR PROCEDURE MAY ! 1493: * OPERATE. OTHERWISE A LOOP OF STACK OVERFLOWS MAY OCCUR. ! 1494: EJC ! 1495: * ! 1496: * -11- DATA GENERATION INSTRUCTIONS ! 1497: * ! 1498: * THE FOLLOWING INSTRUCTIONS ARE USED TO GENERATE CONSTANT ! 1499: * VALUES IN THE CONSTANT SECTION AND ALSO TO ASSEMBLE ! 1500: * INITIAL VALUES IN THE WORKING STORAGE SECTION. THEY ! 1501: * MAY NOT APPEAR EXCEPT IN THESE TWO SECTIONS. ! 1502: * ! 1503: * 11.1 DAC ADDR ASSEMBLE ADDRESS CONSTANT. ! 1504: * GENERATES ONE WORD CONTAINING THE ! 1505: * SPECIFIED ONE WORD INTEGER ! 1506: * VALUE (ADDRESS). ! 1507: * ! 1508: * 11.2 DIC INTEGER GENERATES AN INTEGER VALUE WHICH ! 1509: * OCCUPIES CFP$I CONSECUTIVE WORDS. ! 1510: * THE OPERAND IS A DIGIT STRING WITH ! 1511: * A REQUIRED LEADING SIGN. ! 1512: * ! 1513: * 11.3 DRC REAL ASSEMBLES A REAL CONSTANT WHICH ! 1514: * OCCUPIES CFP$R CONSECUTIVE WORDS. ! 1515: * THE OPERAND FORM MUST OBEY THE ! 1516: * RULES FOR A FORTRAN REAL CONSTANT ! 1517: * WITH THE EXTRA REQUIREMENT THAT A ! 1518: * LEADING SIGN BE PRESENT. ! 1519: * ! 1520: * 11.4 DTC DTEXT DEFINE TEXT CONSTANT. DTEXT ! 1521: * IS STARTED AND ENDED WITH ANY ! 1522: * CHARACTER NOT CONTAINED IN THE ! 1523: * CHARACTERS TO BE ASSEMBLED. THE ! 1524: * CONSTANT OCCUPIES CONSECUTIVE WORDS ! 1525: * AS DICTATED BY THE CONFIGURATION ! 1526: * PARAMETER CFP$C. ANY UNUSED CHARS ! 1527: * IN THE LAST WORD ARE RIGHT FILLED ! 1528: * WITH ZEROS (I.E. THE CHARACTER ! 1529: * WHOSE INTERNAL CODE IS ZERO). ! 1530: * THE STRING CONTAINS A SEQUENCE OF ! 1531: * LETTERS, DIGITS, BLANKS AND ANY OF ! 1532: * THE FOLLOWING SPECIAL CHARACTERS. ! 1533: * =,$.(*)/+- ! 1534: * NO OTHER CHARACTERS ! 1535: * MAY BE USED IN A DTEXT OPERAND. ! 1536: * ! 1537: * 11.5 DBC VAL ASSEMBLE BIT STRING CONSTANT. THE ! 1538: * OPERAND IS A POSITIVE INTEGER ! 1539: * VALUE WHICH IS INTERPRETED IN ! 1540: * BINARY, RIGHT JUSTIFIED AND LEFT ! 1541: * FILLED WITH ZERO BITS. THUS 5 WOULD ! 1542: * IMPLY THE BIT STRING VALUE 00..101. ! 1543: EJC ! 1544: * ! 1545: * -12- SYMBOL DEFINITION INSTRUCTIONS ! 1546: * ! 1547: * THE FOLLOWING INSTRUCTION IS USED TO DEFINE SYMBOLS ! 1548: * IN THE DEFINITIONS SECTION. IT MAY NOT BE USED ELSEWHERE. ! 1549: * ! 1550: * 12.1 EQU EQOP DEFINE SYMBOL ! 1551: * ! 1552: * THE SYMBOL WHICH APPEARS IN THE LABEL FIELD IS ! 1553: * DEFINED TO HAVE THE ABSOLUTE VALUE GIVEN ! 1554: * BY THE EQOP OPERAND. A GIVEN SYMBOL MAY BE DEFINED ! 1555: * ONLY ONCE IN THIS MANNER, AND ANY SYMBOLS OCCURING ! 1556: * IN EQOP MUST BE PREVIOUSLY DEFINED. ! 1557: * ! 1558: * THE FOLLOWING ARE THE POSSIBILITIES FOR EQOP ! 1559: * ! 1560: * VAL THE INDICATED VALUE IS USED ! 1561: * ! 1562: * VAL+VAL THE SUM OF THE TWO VALUES IS USED. ! 1563: * THIS SUM MUST NOT EXCEED CFP$M ! 1564: * ! 1565: * VAL-VAL THE DIFFERENCE BETWEEN THE TWO ! 1566: * VALUES (MUST BE POSITIVE) IS USED. ! 1567: * ! 1568: * * THIS FORMAT DEFINES THE LABEL BY ! 1569: * USING A VALUE SUPPLIED BY THE ! 1570: * MINIMAL TRANSLATOR. VALUES ARE ! 1571: * REQUIRED FOR THE ! 1572: * CFP$X (CONFIGURATION PARAMETERS) ! 1573: * E$XXX (ENVIRONMENT PARAMETERS) ! 1574: * CH$XX (CHARACTER CODES). ! 1575: * IN ORDER FOR A TRANSLATOR TO ! 1576: * HANDLE THIS FORMAT CORRECTLY THE ! 1577: * DEFINITIONS SECTION MUST BE ! 1578: * CONSULTED FOR DETAILS OF REQUIRED ! 1579: * SYMBOLS AS LISTED AT THE FRONT OF ! 1580: * THE SECTION. ! 1581: EJC ! 1582: * ! 1583: * SYMBOL DEFINITION INSTRUCTIONS (CONTINUED) ! 1584: * ! 1585: * THE FOLLOWING INSTRUCTIONS MAY BE USED TO DEFINE SYMBOLS ! 1586: * IN THE PROCEDURE SECTION. THEY MAY NOT BE USED IN ! 1587: * ANY OTHER PART OF THE PROGRAM. ! 1588: * ! 1589: * 12.2 EXP DEFINE EXTERNAL PROCEDURE ! 1590: * ! 1591: * EXP DEFINES THE SYMBOL APPEARING IN THE LABEL FIELD ! 1592: * TO BE THE NAME OF AN EXTERNAL PROCEDURE WHICH CAN BE ! 1593: * REFERENCED IN A SUBSEQUENT JSR INSTRUCTION. THE ! 1594: * CODING FOR THE PROCEDURE IS EXTERNAL TO THE ! 1595: * CODING OF THE SOURCE PROGRAM IN THIS LANGUAGE. ! 1596: * THE CODE FOR EXTERNAL PROCEDURES MAY BE ! 1597: * REFERRED TO COLLECTIVELY AS THE OPERATING SYSTEM ! 1598: * INTERFACE, OR MORE BRIEFLY, OSINT, AND WILL ! 1599: * FREQUENTLY BE A SEPARATELY COMPILED SEGMENT OF CODE ! 1600: * LOADED WITH SPITBOL TO PRODUCE A COMPLETE SYSTEM. ! 1601: * ! 1602: * 12.3 INP PTYP,INT DEFINE INTERNAL PROCEDURE ! 1603: * ! 1604: * INP DEFINES THE SYMBOL APPEARING IN THE LABEL FIELD ! 1605: * TO BE THE NAME OF AN INTERNAL PROCEDURE AND GIVES ! 1606: * ITS TYPE AND NUMBER OF EXIT PARAMETERS. THE LABEL ! 1607: * CAN BE REFERENCED IN JSR INSTRUCTIONS AND ! 1608: * IT MUST APPEAR LABELLING A PRC INSTRUCTION IN THE ! 1609: * PROGRAM SECTION. ! 1610: * ! 1611: * 12.4 INR DEFINE INTERNAL ROUTINE ! 1612: * ! 1613: * INR DEFINES THE SYMBOL APPEARING IN THE LABEL ! 1614: * FIELD TO BE THE NAME OF AN INTERNAL ROUTINE. THE ! 1615: * LABEL MAY BE REFERENCED IN ANY TYPE OF BRANCH ORDER ! 1616: * AND IT MUST APPEAR LABELLING A RTN INSTRUCTION IN ! 1617: * THE PROGRAM SECTION. ! 1618: EJC ! 1619: * ! 1620: * -13- ASSEMBLY LISTING LAYOUT INSTRUCTIONS ! 1621: * ! 1622: * 13.1 EJC EJECT TO NEXT PAGE ! 1623: * ! 1624: * 13.2 TTL TEXT SET NEW ASSEMBLY TITLE ! 1625: * ! 1626: * TTL IMPLIES AN IMMEDIATE EJECT OF THE ! 1627: * ASSEMBLY LISTING TO PRINT THE NEW TITLE. ! 1628: * ! 1629: * THE USE OF TTL AND EJC CARDS IS SUCH THAT THE ! 1630: * PROGRAM WILL LIST NEATLY IF THE PRINTER PRINTS ! 1631: * AS MANY AS 58 LINES PER PAGE. IN THE EVENT THAT ! 1632: * THE PRINTER DEPTH IS LESS THAN THIS, OR IF THE ! 1633: * LISTING CONTAINS INTERSPERSED LINES (SUCH AS ACTUAL ! 1634: * GENERATED CODE), THEN THE FORMAT MAY BE UPSET. ! 1635: * ! 1636: * LINES STARTING WITH AN ASTERISK ARE COMMENT LINES ! 1637: * WHICH CAUSE NO CODE TO BE GENERATED AND MAY OCCUR ! 1638: * FREELY ANYWHERE IN THE PROGRAM. THE FORMAT FOR ! 1639: * COMMENT LINES IS GIVEN IN SECTION -15-. ! 1640: EJC ! 1641: * ! 1642: * -14- PROGRAM FORM ! 1643: * ! 1644: * THE PROGRAM CONSISTS OF SEPARATE SECTIONS SEPARATED ! 1645: * BY SEC OPERATIONS. THE SECTIONS MUST APPEAR IN THE ! 1646: * FOLLOWING SPECIFIED ORDER. ! 1647: * ! 1648: * 14.1 SEC START OF PROCEDURE SECTION ! 1649: * ! 1650: * (PROCEDURE SECTION) ! 1651: * ! 1652: * SEC START OF DEFINITIONS SECTION ! 1653: * ! 1654: * (DEFINITIONS SECTION) ! 1655: * ! 1656: * SEC START OF CONSTANT STORAGE SECTION ! 1657: * ! 1658: * (CONSTANT STORAGE SECTION) ! 1659: * ! 1660: * SEC START OF WORKING STORAGE SECTION ! 1661: * ! 1662: * (WORKING STORAGE SECTION) ! 1663: * ! 1664: * SEC START OF PROGRAM SECTION ! 1665: * ! 1666: * (PROGRAM SECTION) ! 1667: * ! 1668: * SEC START OF STACK OVERFLOW SECTION ! 1669: * ! 1670: * (STACK OVERFLOW SECTION) ! 1671: * ! 1672: * SEC START OF ERROR SECTION ! 1673: * ! 1674: * (ERROR SECTION) ! 1675: * ! 1676: * 14.2 END END OF ASSEMBLY ! 1677: EJC ! 1678: * ! 1679: * SECTION 10 - PROGRAM FORM ! 1680: * ! 1681: * PROCEDURE SECTION ! 1682: * ! 1683: * THE PROCEDURE SECTION CONTAINS ALL THE EXP ! 1684: * INSTRUCTIONS FOR EXTERNALLY AVAILABLE PROCEDURES ! 1685: * AND INP,INR OPCODES FOR INTERNAL PROCEDURES,ROUTINES ! 1686: * SO THAT A SINGLE PASS MINIMAL TRANSLATOR HAS ADVANCE ! 1687: * KNOWLEDGE OF PROCEDURE TYPES WHEN TRANSLATING CALLS. ! 1688: * ! 1689: * DEFINITIONS SECTION ! 1690: * ! 1691: * THE DEFINITIONS SECTION CONTAINS EQU INSTRUCTIONS ! 1692: * WHICH DEFINE SYMBOLS REFERENCED LATER ON IN THE ! 1693: * PROGRAM, CONSTANT AND WORK SECTIONS. ! 1694: * ! 1695: * CONSTANT STORAGE SECTION ! 1696: * ! 1697: * THE CONSTANT STORAGE SECTION CONSISTS ENTIRELY ! 1698: * OF CONSTANTS ASSEMBLED WITH THE DAC,DIC,DRC,DTC,DBC ! 1699: * ASSEMBLY OPERATIONS. THESE CONSTANTS CAN BE FREELY ! 1700: * REFERENCED BY THE PROGRAM INSTRUCTIONS. ! 1701: * ! 1702: * WORKING STORAGE SECTION ! 1703: * ! 1704: * THE WORKING STORAGE SECTION CONSISTS ENTIRELY OF ! 1705: * DAC,DIC,DRC,DBC,DTC INSTRUCTIONS TO DEFINE A FIXED ! 1706: * LENGTH WORK AREA. THE WORK LOCATIONS IN THIS AREA ! 1707: * CAN BE DIRECTLY REFERENCED IN PROGRAM INSTRUCTIONS. ! 1708: * THE AREA IS INITIALIZED IN ACCORDANCE WITH THE ! 1709: * VALUES ASSEMBLED IN THE INSTRUCTIONS. ! 1710: * ! 1711: * PROGRAM SECTION ! 1712: * ! 1713: * THE PROGRAM SECTION CONTAINS PROGRAM INSTRUCTIONS ! 1714: * AND ASSOCIATED OPERATIONS (SUCH AS PRC, ENP, ENT). ! 1715: * CONTROL IS PASSED TO THE FIRST INSTRUCTION IN THIS ! 1716: * SECTION WHEN EXECUTION IS INITIATED. ! 1717: * ! 1718: * STACK OVERFLOW SECTION ! 1719: * ! 1720: * THE STACK OVERFLOW SECTION CONTAINS INSTRUCTIONS ! 1721: * LIKE THE PROGRAM SECTION. CONTROL IS PASSED TO THE ! 1722: * FIRST INSTRUCTION IN THIS SECTION FOLLOWING THE ! 1723: * OCCURRENCE OF STACK OVERFLOW, SEE CHK INSTRUCTION. ! 1724: * ! 1725: * ERROR SECTION ! 1726: * ! 1727: * THE ERROR SECTION CONTAINS INSTRUCTIONS LIKE THE ! 1728: * PROGRAM SECTION. CONTROL IS PASSED TO THE FIRST ! 1729: * INSTRUCTION IN THIS SECTION WHEN A PROCEDURE EXIT ! 1730: * CORRESPONDS TO AN ERROR PARAMETER (SEE ERR) ! 1731: * OR WHEN AN ERB OPCODE IS OBEYED. THE ERROR CODE ! 1732: * MUST CLEAN UP THE MAIN STACK AND CATER FOR THE ! 1733: * POSSIBILITY THAT A SUBROUTINE STACK MAY NEED CLEAN ! 1734: * UP. ! 1735: EJC ! 1736: * OSINT ! 1737: * ! 1738: * THOUGH NOT PART OF THE MINIMAL SOURCE, IT IS USEFUL ! 1739: * TO REFER TO THE COLLECTION OF INITIALISATION AND ! 1740: * EXP ROUTINES AS OSINT (OPERATING SYSTEM INTERFACE). ! 1741: * ERRORS OCCURRING WITHIN OSINT PROCEDURES ARE ! 1742: * USUALLY HANDLED BY MAKING AN ERROR RETURN. IF THIS ! 1743: * IS NOT FEASIBLE OR APPROPRIATE, OSINT MAY USE THE ! 1744: * MINIMAL ERROR SECTION TO REPORT ERRORS DIRECTLY BY ! 1745: * BRANCHING TO IT WITH A SUITABLE NUMERIC ERROR ! 1746: * CODE IN WA. ! 1747: EJC ! 1748: * ! 1749: * SECTION 11 - STATEMENT FORMAT ! 1750: * ! 1751: * ALL LABELS ARE EXACTLY FIVE CHARACTERS LONG AND START ! 1752: * WITH THREE LETTERS (ABCDEFGHIJKLMNOPQRSTUVWXY$) FOLLOWED ! 1753: * BY TWO LETTERS OR DIGITS. ! 1754: * THE LETTER Z MAY NOT BE USED IN MINIMAL SYMBOLS BUT $ IS ! 1755: * PERMITTED. ! 1756: * FOR IMPLEMENTATIONS WHERE $ MAY NOT APPEAR IN THE ! 1757: * TARGET CODE , A SIMPLE SUBSTITUTION OF Z FOR $ ! 1758: * MAY THUS BE MADE WITHOUT RISK OF PRODUCING NON-UNIQUE ! 1759: * SYMBOLS. ! 1760: * THE LETTER Z IS HOWEVER PERMITTED IN OPCODE MNEMONICS AND ! 1761: * IN COMMENTS. ! 1762: * ! 1763: * MINIMAL STATEMENTS ARE IN A FIXED FORMAT AS FOLLOWS. ! 1764: * ! 1765: * COLS 1-5 LABEL IF ANY (ELSE BLANK) ! 1766: * ! 1767: * COLS 6-7 ALWAYS BLANK ! 1768: * ! 1769: * COLS 8-10 OPERATION MNEMONIC ! 1770: * ! 1771: * COLS 11-12 BLANKS ! 1772: * ! 1773: * COLS 13-28 OPERAND FIELD, TERMINATED BY A ! 1774: * BLANK. MAY OCCASIONALLY ! 1775: * EXTEND PAST COLUMN 28. ! 1776: * ! 1777: * COLS 30-64 COMMENT. ALWAYS SEPARATED FROM THE ! 1778: * OPERAND FIELD BY AT LEAST ONE BLANK ! 1779: * MAY OCCASIONALLY START AFTER COLUMN ! 1780: * 30 IF THE OPERAND EXTENDS PAST 28. ! 1781: * A SPECIAL EXCEPTION OCCURS FOR THE ! 1782: * IFF INSTRUCTION, WHOSE COMMENT MAY ! 1783: * BE ONLY 20 CHARACTERS LONG (30-49). ! 1784: * ! 1785: * COLS 65 ON UNUSED ! 1786: * ! 1787: * ! 1788: * COMMENT LINES HAVE THE FOLLOWING FORMAT ! 1789: * ! 1790: * COL 1 ASTERISK ! 1791: * ! 1792: * COLS 2-7 BLANK ! 1793: * ! 1794: * COLS 8-64 ARBITRARY TEXT, RESTRICTED TO THE ! 1795: * FORTRAN CHARACTER SET. ! 1796: * ! 1797: * ! 1798: * THE FORTRAN CHARACTER SET IS A-Z 0-9 =,$.(*)-/+ ! 1799: EJC ! 1800: * ! 1801: * SECTION 12 - PROGRAM EXECUTION ! 1802: * ! 1803: * EXECUTION OF THE PROGRAM BEGINS WITH THE FIRST ! 1804: * INSTRUCTION IN THE PROGRAM SECTION. ! 1805: * ! 1806: * IN ADDITION TO THE FIXED LENGTH MEMORY REGIONS DEFINED ! 1807: * BY THE ASSEMBLY, THERE ARE TWO DYNAMICALLY ALLOCATED ! 1808: * MEMORY REGIONS AS FOLLOWS. ! 1809: * ! 1810: * DATA AREA THIS IS AN AREA AVAILABLE TO THE ! 1811: * PROGRAM FOR GENERAL STORAGE OF DATA ! 1812: * ANY DATA VALUE MAY BE STORED IN ! 1813: * THIS AREA EXCEPT INSTRUCTIONS. ! 1814: * IN SOME IMPLEMENTATIONS, IT MAY BE ! 1815: * POSSIBLE TO INCREASE THE SIZE OF ! 1816: * THIS AREA DYNAMICALLY BY ADDING ! 1817: * WORDS AT THE TOP END WITH A CALL ! 1818: * TO A SYSTEM PROCEDURE. ! 1819: * ! 1820: * STACK AREA THIS REGION OF MEMORY HOLDS ! 1821: * THE STACK USED FOR SUBROUTINE CALLS ! 1822: * AND OTHER STORAGE OF ONE WORD ! 1823: * INTEGER VALUES (ADDRESSES). THIS ! 1824: * IS THE STACK ASSOCIATED WITH ! 1825: * INDEX REGISTER XS. ! 1826: * ! 1827: * THE LOCATIONS AND SIZES OF THESE AREAS ARE SPECIFIED ! 1828: * BY THE VALUES IN THE REGISTERS AT THE START OF PROGRAM ! 1829: * EXECUTION AS FOLLOWS. ! 1830: * ! 1831: * (XS) ADDRESS ONE PAST THE STACK BASE. ! 1832: * E.G. IF XS IS 23456, A D-STACK WILL ! 1833: * OCCUPY WORDS 23455,23454,... ! 1834: * WHEREAS A U-STACK WILL OCCUPY ! 1835: * 23457,23458,... ! 1836: * ! 1837: * (XR) ADDRESS OF THE FIRST WORD ! 1838: * IN THE DATA AREA ! 1839: * ! 1840: * (XL) ADDRESS OF THE LAST WORD IN THE ! 1841: * DATA AREA. ! 1842: * ! 1843: * ! 1844: * (WA,WB,WC,IA,RA,CP) ZERO ! 1845: * ! 1846: * THERE IS NO EXPLICIT WAY TO TERMINATE THE EXECUTION OF A ! 1847: * PROGRAM. THIS FUNCTION IS PERFORMED BY AN APPROPRIATE ! 1848: * SYSTEM PROCEDURE REFERENCED WITH THE SYSEJ INSTRUCTION.
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.