*COMDECK 18BITSUBS
_$J+? 
_***********************************************************************
*                                                                      *
*                   18-BIT ADDRESS MANIPULATIONS                       *
*                                                                      *
*     THREE SUBROUTINES ARE AVAILABLE TO PERFORM NEEDED 18-BIT         *
*     ADDRESS FUNCTIONS:                                               *
*                                                                      *
*              1) ADD TWO 18-BIT ADDRESSES                             *
*              2) READ CONTENTS OF A GIVEN 18-BIT ADDRESS              *
*              3) STORE INTO A GIVEN 18-BIT ADDRESS                    *
*              4) CLEAR PROTECT BIT AT A GIVEN 18-BIT ADDRESS          *
*              5) SET PROTECT BIT AT A GIVEN 18-BIT ADDRESS            *
*              6) COMPARE TWO 18-BIT ADDRESSES                         *
*              7) FORM 18-BIT ADDR FROM 16-BIT ADDR                    *
*                                                                      *
*     IN ALL PROGRAMS, THE 18-BIT ADDRESS IS PASSED IN TWO             *
*     WORDS- THE FIRST WORD CONTAINS THE UPPER 7 BITS OF               *
*     THE ADDRESS AND THE SECOND WORD CONTAINS THE LOWER 16            *
*     BITS OF THE ADDRESS (FOR EASE OF HANDLING SINGLE                 *
*     PROCESSOR, NON-PAGED SYSTEMS).                                   *
*                                                                      *
***********************************************************************?
_$J+? 
_*****************************
*                            *
*         PB18ADD            *
*  ADD TWO 18-BIT NUMBERS    *
*                            *
*****************************?
_$R-,G-,I+     NON-RECURSIVE
               NON-INTERRUPTABLE ?
_***********************************************************************
*                                                                      *
**OVERVIEW- PB18ADD SUMS TWO 18-BIT NUMBERS, RETURNING THE             *
*           SUM IN THE SECOND 18-BIT ADDRESS.                          *
*                                                                      *
**INPUT- TWO 18-BIT ADDRESSES FORMATTED AS DEFINED ABOVE.              *
*                                                                      *
**OUTPUT- ADDITION PERFORMED.                                          *
*                                                                      *
**EXTERNAL SUBROUTINES- NONE                                           *
*                                                                      *
***********************************************************************?
PROCEDURE PB18ADD(A : B018BITS; VAR B : B018BITS);
VAR PAGENUM : INTEGER;
BEGIN 
  WITH B,B0WORD DO
  BEGIN 
    PAGENUM := BAPAGE;                      _SAVE PAGE NUMBER          ?
    BAPAGE  := 0;                           _CLEAR FOR OVERFLOW TEST   ?
    BAINT   := BAINT+A.B0WORD.BA11BITS;     _ADD LOWER 11 BITS         ?
    B0UPPER7.BASP9 := 0;                    _CLEAR FOR OVERFLOWTTEST   ?
    B0UPPER7.BAINT := B0UPPER7.BAINT+       _ADD UPPER 7 BITS          ?
                      A.B0UPPER7.BA7BITS; 
    IF 0 " BAPAGE                           _CHECK FOR OF ON LOWER 11  ?
    THEN B0UPPER7.BAINT := B0UPPER7.BAINT+1;_CARRY TO UPPER 7          ?
    IF 0 " B0UPPER7.BASP9 THEN              _CHECK FOR OF ON UPPER 7   ?
    BEGIN 
      BAPAGE := 0;                          _CLEAR FOR OVERFLOW TEST   ?
      BAINT  := BAINT+1;                    _ONE#S COMPLEMENT CARRY    ?
      IF 0 " BAPAGE                         _CHECK AGAIN FOR OVERFLOW  ?
      THEN B0UPPER7.BA7BITS :=              _CARRY TO UPPER 7          ?
           B0UPPER7.BA7BITS+1;
    END;
    BAPAGE := PAGENUM;                      _RESTORE PAGE NUMBER       ?
    B0UPPER7.BASP9 := 0;                    _CLEAR OVERFLOW AREA       ?
  END; _WITH? 
END; _PB18ADD?
_$J+? 
_*****************************
*                            *
*         PB18BITS           *
*  18-BIT ADDRESS FUNCTIONS  *
*                            *
*****************************?
_$R-,G-,I+     NON-RECURSIVE
               NON-INTERRUPTABLE ?
_***********************************************************************
*                                                                      *
**OVERVIEW- PB18BITS PERFORMS THE FOLLOWING FUNCTIONS ON 18-BIT        *
*           ADDRESSES:                                                 *
*                                                                      *
*                  1) STORE INTO GIVEN 18-BIT ADDRESS                  *
*                  2) READ FROM GIVEN 18-BIT ADDRESS                   *
*                  3) CLEAR PROTECT BIT ON GIVEN 18-BIT ADDRESS        *
*                  4) SET PROTECT BIT ON GIVEN 18-BIT ADDRESS          *
*                  5) FORM 18-BIT ADDR FROM 16-BIT ADDR.               *
*                                                                      *
**INPUT- 18-BIT ADDRESS, 16-BIT WORD TO LOAD OR STORE AND CODE         *
*        OF FUNCTION TO PERFORM (OF TYPE J018BITS).                    *
*                                                                      *
**OUTPUT- PROPER FUNCTION PERFORMED.                                   *
*                                                                      *
**EXTERNAL SUBROUTINES-                                                *
*              1) PBPUTPAGE        WRITE PAGE REGISTER                 *
*              2) PBGETPAGE        READ PAGE REGISTER                  *
*              3) PBCLRPROT        CLEAR PROTECT BIT                   *
*              4) PBSETPROT        SET PROTECT BIT                     *
*                                                                      *
***********************************************************************?
PROCEDURE PB18BITS(VAR ADDR : B018BITS;     _18-BIT ADDRESS            ?
                   VAR PARAM : INTEGER;     _LOAD/READ PARAMETER       ?
                   FNCTION : J018BITS);     _FUNCTION CODE             ?
VAR PAGENUM,
    PAGECONTENTS : INTEGER; 
    LOCAL : INTEGER;
    TEMP : INTEGER; 
BEGIN 
  WITH ADDR,B0WORD DO 
  IF FNCTION = J0XFORM THEN 
  BEGIN 
    TEMP := PARAM;
    ADDR := ZERO;                           _CLEAR ADDRESS             ?
    BAINT:= TEMP;                           _MOVE IN PAGE, LOWER 11    ?
    IF BAPAGE \ DYNAMICPAGE THEN            _CHECK IF DYNAMIC PAGING   ?
    BEGIN 
      PBGETPAGE(BAPAGE,LOCAL);              _READ PAGE CONTENTS        ?
      B0UPPER7.BA7BITS := LOCAL;            _SET UP UPPER7 BITS        ?
    END ELSE B0UPPER7.BA7BITS := BAPAGE;    _SET UP UPPER7 BITS        ?
  END ELSE
  BEGIN 
    PAGENUM := BAPAGE;                      _SAVE PAGE NUMBER          ?
    BAPAGE  := DYNAMICPAGE;                 _SET UP DYNAMIC PAGE NUMBER?
    PBGETPAGE(DYNAMICPAGE,PAGECONTENTS);    _SAVE DYNAMIC PAGE CONTENTS?
    PBPUTPAGE(DYNAMICPAGE,B0UPPER7.BA7BITS);_WRITE DYNAMIC PAGE        ?
    CASE FNCTION OF 
_?
    J0LOAD: 
    BAINTPTR' := PARAM;                     _STORE VALUE               ?
_?
    J0GET:  
    PARAM := BAINTPTR';                     _READ VALUE                ?
_?
    J0CLRP: 
    PBCLRPROT(B0WORD);                      _CLEAR PROTECT BIT         ?
_?
    J0SETP: 
    PBSETPROT(B0WORD);                      _SET PROTECT BIT           ?
_?
    END;
    BAPAGE := PAGENUM;                      _RESTORE PAGE NUMBER       ?
    PBPUTPAGE(DYNAMICPAGE,PAGECONTENTS);    _RESTORE PAGE CONTENTS     ?
  END; _WITH? 
END; _PB18BITS? 
_$J+? 
_*****************************
*                            *
*          PB18COMP          *
*  COMPARE 2 18-BIT NUMBERS  *
*                            *
*****************************?
_$R-,G-,I+     NON-RECURSIVE
               NON-INTERRUPTABLE ?
_***********************************************************************
*                                                                      *
**OVERVIEW- PB18COMP IS A BOOLEAN FUNCTION RETURNING THE RESULT        *
*           OF THE FOLLOWING COMPARES OF 18-BIT ADDRESSES A AND B:     *
*                                                                      *
*                  TRUE IF A COMP B                                    *
*                  WHERE COMP IS =,",>,\,< OR @.                       *
*                                                                      *
**INPUT- TWO NUMBERS TO COMPARE AND COMPARISON TO PERFORM.             *
*                                                                      *
**OUTPUT- RESULT OF COMPARISON.                                        *
*                                                                      *
**EXTERNAL SUBROUTINES- NONE                                           *
*                                                                      *
***********************************************************************?
FUNCTION PB18COMP; _ (A : B018BITS;         FIRST PARAMETER 
                      COMP : J018COMP;      COMPARISON TO MAKE
                      B : B018BITS)         SECOND PARAMETER
                                    : BOOLEAN; FORWARD                 ?
BEGIN 
  WITH A,B0WORD DO
  CASE COMP OF                              _18-BIT COMPARES           ?
_?
    J0EQ:                                   _A = B                     ?
    PB18COMP := (B0UPPER7.BA7BITS = 
                 B.B0UPPER7.BA7BITS) &
                (BA11BITS = B.B0WORD.BA11BITS); 
_?
    J0NE:                                   _A " B                     ?
    PB18COMP := (B0UPPER7.BA7BITS " 
                 B.B0UPPER7.BA7BITS) !
                (BA11BITS " B.B0WORD.BA11BITS); 
_?
    J0GR:                                   _A > B                     ?
    PB18COMP := (B0UPPER7.BA7BITS > 
                 B.B0UPPER7.BA7BITS) !
               ((B0UPPER7.BA7BITS = 
                 B.B0UPPER7.BA7BITS) &
                (BA11BITS > B.B0WORD.BA11BITS));
_?
    J0GRE:                                  _A \ B                     ?
    PB18COMP := (B0UPPER7.BA7BITS > 
                 B.B0UPPER7.BA7BITS) !
               ((B0UPPER7.BA7BITS = 
                 B.B0UPPER7.BA7BITS) &
                (BA11BITS \ B.B0WORD.BA11BITS));
_?
    J0LT: 
    PB18COMP := (B0UPPER7.BA7BITS <         _A < B                     ?
                 B.B0UPPER7.BA7BITS) !
               ((B0UPPER7.BA7BITS = 
                 B.B0UPPER7.BA7BITS) &
                (BA11BITS < B.B0WORD.BA11BITS));
_?
    J0LTE:                                  _A @ B                     ?
    PB18COMP := (B0UPPER7.BA7BITS < 
                 B.B0UPPER7.BA7BITS) !
               ((B0UPPER7.BA7BITS = 
                 B.B0UPPER7.BA7BITS) &
                (BA11BITS @ B.B0WORD.BA11BITS));
_?
  END;
END; _PB18COMP? 
