|
DataMuseum.dkPresents historical artifacts from the history of: Bogika Butler |
This is an automatic "excavation" of a thematic subset of
See our Wiki for more about Bogika Butler Excavated with: AutoArchaeologist - Free & Open Source Software. |
top - metrics - download
Length: 7168 (0x1c00)
Types: TextFile
Names: »DIS.SA«
└─⟦909f4eb2b⟧ Bits:30009789/_.ft.Ibm2.50006622.imd Mogens Pelles Zilog 80,000 / EOS projekt
└─⟦this⟧ »DIS.SA«
└─⟦ddcd65152⟧ Bits:30009789/_.ft.Ibm2.50006617.imd Mogens Pelles Zilog 80,000 / EOS projekt
└─⟦this⟧ »DIS.SA«
NOLIST
INCLUDE RR.RTEQU.SA
INCLUDE RR.MACROS.SA
LIST
*
* FILE RR.RTEQU.SA HAS BEEN INCLUDED
* FILE RR.MACROS.SA HAS BEEN INCLUDED
*
TTL V 0.01 68K EOS PASCAL DISPOSE (HEAP DEALLOCATION) SUBROUTINE
DIS IDNT 0,01 68K EOS PASCAL DISPOSE (HEAP DEALLOCATION) SUBROUTINE
SECTION 8
*
*********
*
* DIS, DIPOSE OF A SEGMENT AND INSERT INTO THE FREE LIST
*
* ENTRY:
* A0 = POINTER TO THE VARIABLE THAT CONTAINS A POINTER TO
* THE SEGMENT TO BE DISPOSED OF
*
* THE WORD AFTER THE SUBROUTINE CALL = THE LENGTH OF THE
* SEGMENT BEING DISPOSED.
*
* EXIT:
* NONE.
*
* USES:
* 0 1 2 3 4 5 6 7
* A: * * * X X X X A
* D: * * X X * X X *
*
*
* UPDATED FOR EOS PASCAL USE
*
*
* FUNCTION:
*
* DIS MAKES A COPY OF THE POINTER TO THE SEGMENT TO FREE UP, AND
* SETS THE USERS POINTER BACK TO NIL. IT THEN CHECKS TO MAKE SURE
* THAT THE POINTER IS POINTING TO A VALID PLACE IN THE HEAP. IF THE
* POINTER ISN'T VALID THEN A RUNTIME ERROR IS GENERATED. THE FREE
* LIST IS THEN SEARCHED FOR THE PROPER PLACE TO INSERT THE NEW
* ELEMENT. AFTER IT HAS BEEN INSERTED A CHECK IS MADE TO SEE IF
* IT CAN BE MERGED WITH THE FREE LIST ELEMENT AT A LOWER MEMORY
* ADDRESS, AND IF IT CAN BE MERGED IT IS. THEN A CHECK IS MADE TO SEE
* IF THE POSSIBLY MERGED NEW ELEMENT CAN BE MERGED WITH THE ONE AT
* A HIGHER MEMORY ADDRESS. IF IT IS POSSIBLE THEN THEY ARE MERGED.
* IF THE SEGMENT BEING DISPOSED IS AT BTHE TOP OF THE HEAP THEN THE
* HEAP IS CUT BACK.
*
* EXTERNALS:
* .PDIS = DEF, ENTRY POINT FOR THE DISPOSE RUNTIME ROUTINE
* .PDISL = DEF, ENTRY POINT FOR THE LONG DISPSE ROUTINE
*
* .PCHKOVF = REF, ROUTINE TO CHECK FOR STACK HEAP OVERFLOW
* .PCHKOBJ = REF, ROUTINE TO CHECK FOR OBJECT CALL
*
*********
*
XDEF .PDIS ! ENTRY POINT FOR THE DISPOSE RUNTIME ROUTINE
XDEF .PDISL
XREF .PCHKOBJ ! CHECK FOR OBJECT CALL
XREF .PCHKOVF ! CHECK FOR STACK HEAP OVERFLOW ROUTINE
*
.PDISL EQU * ! ENTRY POINT FOR LARGE DISPOSE ROUTINE
*
ADDQ.L #2,(A7) ! ADJUST RETURN ADDRESS TO POINT PAST LEN LWORD
*
.PDIS: EQU * ! ENTRY POINT FOR DISPOSE ROUTINE
*
ADDQ.L #2,(A7) ! ADJUST RETURN ADDRESS TO POINT PAST LEN WORD
MOVE.L (A7),D7 ! D7 = RETURN ADDRESS IN CASE OF ERROR
BSR .PCHKOBJ ! ERROR IF OBJECT CALL
*
* CHECK FOR STACK/HEAP OVERFLOW
*
BSR .PCHKOVF ! ERROR IF THE STACK HAS BUMPED INTO THE HEAP
*
* COPY AND CLEAR POINTER TO SEGMENT TO DISPOSE
*
MOVE.L (A0),A2 ! A2 = POINTER TO SEGMENT TO DISPOSE
CLR.L (A0) ! USERS POINTER NOW EQUALS NIL
*
* CHECK IF SEGMENT IS BELOW TOP OF HEAP, AND IGNORE DISPOSE CALL IF NOT
*
MOVE.L 4(A5),A0 ! A0 = POINTER TO TOP OF HEAP
SUBQ.L #8,A0 ! A0 = POINTER TO THE TOP OF HEAP RECORD
CMP.L A0,A2 ! IS POINTER POINTING INTO THE HEAP ?
BHI.S DIS4 ! NO, THEN IGNORE THE DISPOSE CALL
*
* PUT IN CODE HERE TO MAKE SURE THAT THE POINTER IS ABOVE THE BOTTOM
* OF THE HEAP
*
* PREPARE TO FIND THE PLACE IN THE FREE LIST THAT THIS NEW SEGMENT
* SHOULD BE INSERTED INTO.
*
CLR.L D0 ! D0 = PTR TO FREE LIST ELEMENT 2 AFTER CURRENT
SUB.L A1,A1 ! A1 = PTR TO FREE LIST ELEMENT 1 AFTER CURRENT
MOVE.L -(A2),D4 ! D4 = LEN OF SEGMENT, A2 = PTR TO SEG TO DISPOSE
*
* SEARCH THE FREE LIST TO FIND THE PLACE WHERE THE NEW ELEMENT SHOULD
* BE INSERTED
*
DISL1: CMP.L A0,A2 ! IS THIS WHERE THE NEW ELEMENT BELONGS ?
BHI.S DIS1 ! YES, THEN GO INSERT IT HERE
*
* THIS WASN'T WHERE THE NEW ELEMENT BELONGS
*
MOVE.L A1,D0 ! D0 = NEW 2 AFTER CURRENT POINTER
MOVE.L A0,A1 ! A1 = NEW 1 AFTER CURRENT POINTER
MOVE.L 4(A0),A0 ! A0 = NEW CURRENT POINTER
BRA.S DISL1 ! LOOP, UNTIL RIGHT PLACE TO INSERT IS FOUND
*
* THE PLACE WAS FOUND TO INSERT THE NEW ELEMENT INTO THE FREE LIST
*
DIS1: MOVE.L A0,4(A2) ! LINK NEW ELEMENT TO NEXT FREE ELEMENT
MOVE.L A2,4(A1) ! LINK PREVIOUS FREE ELEMENT TO THE NEW ONE
*
* CHECK IF THE NEW FREE ELEMENT CAN BE MERGED WITH THE ONE BEFORE IT
*
MOVE.L A0,D1 ! D1 = PTR TO ELEMENT BEFORE ONE BEING INSERTED
BEQ.S DIS2 ! IF NIL THEN THERE IS NO ELEMENT TO MERGE WITH
ADD.L (A0),D1 ! D1 = PTR TO END OF ELEMENT BEFORE NEW ONE
CMP.L D1,A2 ! CAN THE TWO ELEMENTS BE MERGED ?
BHI.S DIS2 ! NO, THEN CHECK IF THE 1 AFTER CAN BE MERGED
*
* MERGE THE NEW ELEMENT WITH THE ONE BEFORE IT (IN LOWER MEMORY)
*
SUB.L A0,A2 ! A2 = LENGTH OF OLD SEGMENT
ADD.L A2,D4 ! D4 = LENGTH OF THE TWO MERGED TOGETHER
MOVE.L D4,(A0) ! SAVE THE NEW LENGTH
MOVE.L A0,A2 ! A2 = PTR TO THE NEW MERGED ELEMENT
MOVE.L A2,4(A1) ! FIX UP THE LINK TO THE MERGED ELEMENT
*
* CHECK IF NEW ELEMENT CAN BE MERGED WITH THE ONE AFTER IT
*
DIS2: MOVE.L A2,D1 ! D1 = PTR TO THE NEW ELEMENT
ADD.L D4,D1 ! D1 = PTR TO THE END OF THE NEW ELEMENT
CMP.L D1,A1 ! CAN THE TWO ELEMENTS BE MERGED ?
BHI.S DIS4 ! NO, THEN CLEAN UP AND RETURN
*
* CHECK IF ELEMENTS SHOULD BE MERGED OR IF THE HEAP SHOULD BE CUT
* BACK.
*
TST.L D0 ! SHOULD THE HEAP BE CUT BACK (YES IF D0 = 0)
BNE.S DIS3 ! NO, GO MERGE THE TWO ELEMENTS
*
* CUT BACK THE HEAP
*
MOVE.L (A1),(A2) ! MOVE THE TOP OF HEAP RECORD BACK
ADDQ.L #8,A2 ! ADJUST POINTER TO POINT ABOVE TOP OF HEAP RECORD
MOVE.L A2,4(A5) ! SAVE NEW TOP OF HEAP PTR IN THE R.M.A.
BRA.S DIS4 ! GO CLEAN UP AND RETURN TO THE PASCAL PROGRAM
*
* MERGE THE NEW SEGMENT WITH THE ONE AFTER IT.
*
DIS3: MOVE.L A1,D1 ! D1 = PTR TO FREE ELEMENT AFTER NEW ONE
SUB.L A2,D1 ! D1 = LENGTH OF NEW ELEMENT
ADD.L (A1),D1 ! D1 = LENGTH OF MERGED ELEMENT
MOVE.L D1,(A2) ! SAVE THE LENGTH OF THE MERGED ELEMENT
MOVE.L D0,A0 ! A0 = PTR TO THE ELEMENT TWO BEFORE THE NEW ONE
MOVE.L A2,4(A0) ! LINK THE NEW MERGED ELEMENT INTO THE FREE LIST
*
* CLEAN UP AND RETURN TO THE PASCAL PROGRAM
*
DIS4: RTS ! RETURN TO THE PASCAL PROGRAM
END
«eof»