ASMB,R,L,C,Z
      HED (FMP) IDMEM: LOCATE REAL-TIME MEMORY CONFLICTS
*     NAME:   IDMEM 
*     SOURCE: 92071-18061 
*     RELOC:  92071-16061 
*     PGMR:   M.L.K.
*     MOD:    E.D.B.
* 
*  ***************************************************************
*  * (C) COPYRIGHT HEWLETT-PACKARD COMPANY 1980.  ALL RIGHTS     *
*  * RESERVED.  NO PART OF THIS PROGRAM MAY BE PHOTOCOPIED,      *
*  * REPRODUCED OR TRANSLATED TO ANOTHER PROGRAM LANGUAGE WITHOUT*
*  * THE PRIOR WRITTEN CONSENT OF HEWLETT-PACKARD COMPANY.       *
*  ***************************************************************
* 
* 
      NAM IDMEM,7 92071-1X061 REV.2041 800409 
* 
      ENT IDMEM 
* 
      EXT .ENTR 
      IFN           *** L/10 CODE *** 
      EXT $FWRT, $FWBG, $BGBP, $ID#, $IDA, $IDSZ
      XIF 
      SUP 
      SKP 
* 
*     DESCRIPTION 
* 
*     THIS MODULE WILL FIND ANY REAL-TIME PROGRAM WHOSE MEMORY
*     BOUNDS CONFLICT IN ANY WAY WITH THE MEMORY BOUNDS PASSED TO 
*     IT.  IT IS USED TO DETERMINE IF THERE EXITS A REAL TIME 
*     PROGRAM WHOSE MEMORY BOUNDS WOULD CONFLICT WITH ONE WHICH IS
*     BEING SET UP BY RP. 
* 
*     CALLING SEQUENCE: 
* 
*     IADDR = IDMEM(IADBF)
* 
*     WHERE:
* 
*     IADBF = POINTER TO A SKELETON ID SEGMENT FROM 
*             A TYPE 6 FILE 
* 
*     IDADR = 0 IF NO CONFLICT OR NOT A REAL-TIME PROGRAM 
*             ID SEGMENT ADDRESS OF NAME OF CONFLICTING 
*             PROGRAM 
* 
*     SPECIAL ASSEMBLY INSTRUCTIONS:
*     THIS FILE CONTAINS SOURCE CODE FOR BOTH THE RTE-L AND RTE-L/20
*     IDMEM ROUTINES.  ASSEMBLE THE CODE WITH THE N OPTION TO CREATE
*     THE RTE-L VERSION, AND WITH THE Z OPTION TO CREATE THE RTE-L/20 
*     VERSION.
      SKP 
* 
*     ENTRY 
* 
NUID  NOP 
* 
IDMEM NOP 
      JSB .ENTR     SET UP PARAMETERS 
      DEF NUID
* 
      IFN           *** L/10 CODE *** 
      LDA $FWBG     GET FIRST WORD OF BACKGROUND
      CMA,INA       COMPLEMENT AND SAVE 
      STA FWBG      FOR REAL TIME/BACKGROUND TEST 
* 
*     SET UP NEW ADDRESSES FROM CALLER'S ID SEGMENT 
* 
      LDB NUID      GET ID ADDRESS
      ADB .20       POINT TO WORD 21
      LDA B,I       GET NEW LOW MAIN
      STA NULO      AND SAVE IT 
* 
      ADB .3        NOW POINT TO WORD 24
      LDA B,I       AND GET LOW BASE PAGE 
      AND B1777     AND ISOLATE IT
      STA NULOB     STORE IT
* 
      ADB .9        POINT TO WORD 33.  LOADER SET THIS
      LDA B,I       TO HIGHEST PROGRAM ADDRESS + 1
      ADA N1        SUBTRACT 1 FOR HIGHEST ADDRESS
      STA NUHI      SAVE IT 
* 
      INB           NOW POINT TO WORD 34.  LOADR SETS THIS
      LDA B,I       TO HIGH BP ADDRESS + 1
      ADA N1        SUBTRACT 1 FOR HIGHEST BP ADDRESS 
      STA NUHIB     AND SAVE
* 
*     CHECK IF THIS IS A REAL-TIME PROGRAM
* 
      LDA NULO      TEST IF THE LOW BOUND IS IN 
      JSB BCHEK     REAL-TIME AREA.  IF SO, ASSUME
      DEF $FWRT+0   THE LOADR HAS CHECKED THE REST
      DEF $FWBG+0    OF THE BOUNDARIES
      SZA,RSS       REAL-TIME?
      JMP EXIT      NO, EXIT OK.
      SKP 
* 
*     INITIALIZE LOOP 
* 
      LDA $ID#      GET NUMBER OF ID SEGMENTS 
      CMA,INA       SET IT NEGATIVE 
      STA COUNT     AND SAVE FOR LOOP COUNT 
* 
      LDA $IDA      GET ADDRESS OF FIRST ID 
      ADA .12       AND POINT TO NAME (FOR ACTIVE CHECK)
      STA IDPTR     AND SAVE ID POINTER 
      SKP 
* 
*     TEST ID 
* 
LOOP  LDB IDPTR,I   GET FIRST NAME WORD 
      SZB,RSS       IF IT IS 0, THE ID NOT USED 
      JMP NEXT      NOT IN USE, DO NEXT 
* 
      LDB IDPTR     SET UP ID'S BOUNDS
      ADB .8        POINT TO LOW MAIN 
      LDA B,I       GET ADDRESS FROM ID 
      STA MLO       AND SAVE IN MAIN LOW
      ADA FWBG      ADD THE NEGATIVE FIRST WORD OF BACKGROUND 
      SSA,RSS       THIS ID RT OR BG? 
      JMP NEXT      BG, SKIP IT, CAN'T CONFLICT 
* 
      INB           POINT TO HIGH MAIN+1
      LDA B,I       GET ADDRESS FROM ID 
      STA MHI       AND SAVE IN MAIN HIGH 
* 
      ADB .2        POINT TO LOW BASE PAGE/#SEGMENTS
      LDA B,I       GET ADDRESS FROM ID 
      AND B1777     ISOLATE LOW BASE PAGE 
      STA BLO       SAVE IN BASE PAGE LOW 
      LDA B,I       GET WORD AGAIN
      ALF,ALF       POSITION # OF SEGMENTS
      RAR,RAR         TO LOW BITS 
      AND B77       AND ISOLATE 
      STA NUMSG     SAVE NUMBER OF SEGMENTS 
* 
      INB           POINT TO HIGH BASE PAGE 
      LDA B,I       GET ADDRESS FROM ID 
      AND B1777     ISOLATE ADDRESS 
      STA BHI       SAVE IN BASE PAGE HIGH
* 
      LDA NUMSG     GET NUMBER OF SEGMENTS
      SZA,RSS       SEGMENTED?
      JMP CKBND     NO, CHECK MEMORY BOUNDS 
* 
      LDA $FWBG     USE BG BOUNDRY FOR SEGMENTED PROGS
      STA MHI       SAVE HIGHEST MAIN ADDRESS 
      LDA $BGBP     USE BG BP BOUNDRY FOR SEGMENTED 
      STA BHI       SAVE HIGHEST BASE PAGE ADDRESS
* 
CKBND LDA NULO      CHECK NEW LOW BOUND 
      JSB BCHEK     CHECK BOUNDS
      DEF MLO 
      DEF MHI 
      STA BNDCK     SAVE CONFLICT VALUE 
      STB AB.BL     SAVE ABOVE/BELOW INDICATOR
      LDA NUHI      CHECK NEW HIGH BOUND
      JSB BCHEK 
      DEF MLO 
      DEF MHI 
      ADA BNDCK     ADD PREVIOUS CHECK
      SZA           LOW AND HIGH BOUNDS OK? 
      JMP ERBND     NO, ERROR 
* 
      ADB AB.BL     YES, NOW TEST IF BOTH BOUNDS ON SAME SIDE 
      SZB,RSS         OF THIS PROGRAM 
      JMP ERBND     NO, SPANS THIS PROGRAM, ERROR.
* 
      LDA NULOB     NOW CHECK LOW BP BOUND
      JSB BCHEK 
      DEF BLO 
      DEF BHI 
      STA BNDCK     SAVE CONFLICT VALUE 
      STB AB.BL     SAVE ABOVE/BELOW INDICATOR
      LDA NUHIB     NOW CHECK HIGH BP BOUND 
      JSB BCHEK 
      DEF BLO 
      DEF BHI 
      ADA BNDCK     ADD PREVIOUS CHECK
      SZA           LOW AND HIGH BP BOUNDS OK?
      JMP ERBND     NO, RETURN
* 
      ADB AB.BL     YES, NOW TEST IF BOTH BOUNDS ON SAME SIDE 
      SZB,RSS         OF THIS PROGRAM 
      JMP ERBND     NO, NEW PROGRAM SPANS THIS ONE, ERROR 
* 
NEXT  LDA IDPTR     GET ID POINTER
      ADA $IDSZ     AND INCREMENT TO NEXT ONE 
      STA IDPTR     SAVE FOR NEXT ROUND 
      ISZ COUNT     INCREMENT COUNT 
      JMP LOOP      DO IT AGAIN 
      XIF 
      SKP 
* 
*     EXIT
* 
EXIT  CLA           DONE, NO CONFLICTS
      JMP IDMEM,I   EXIT
* 
      IFN           *** L/10 CODE *** 
ERBND LDA IDPTR     ERROR IN BOUNDS.  RETURN POINTER
      JMP IDMEM,I     TO NAME AND EXIT
      XIF 
      SKP 
* 
*     BCHEK: TESTS WHETHER THE A REGISTER IS GREATER THAN 
*            OR EQUAL TO THE FIRST PARAMETER AND LESS THAN
*            THE SECOND PARAMETER.
* 
*     CALLING SEQUENCE: 
* 
*     <A = BOUND> 
*     JSB BCHEK 
*     DEF LO BOUND
*     DEF HI BOUND
*     <RETURN: A = 0 IF NOT BETWEEN BOUNDS, -1 IF BETWEEN;
*              B = -1 IF BELOW LOWER BOUNDRY> 
*             +1 IF ABOVE UPPER BOUNDRY 
* 
      IFN           *** L/10 CODE *** 
BCHEK NOP 
* 
      LDB BCHEK,I   GET ADDRESS OF LOW BOUND
      STB LO        STORE IN LOW
      ISZ BCHEK     POINT TO UPPER BOUND
      LDB BCHEK,I   GET ADDRESS OF HIGH BOUND 
      STB HI
      ISZ BCHEK     POINT TO RETURN ADDRESS 
* 
      LDB LO,I      GET LOW BOUND 
      CMB,INB       AND SET IT NEGATIVE 
      ADB A         ADD IN THE TEST BOUND 
      SSB           IS IT BELOW OR EQUAL OR ABOVE?
      JMP BELOW     BELOW, ITS OK 
* 
      LDB HI,I      EQUAL OR ABOVE SO GET HIGH BOUND
      CMB,INB       AND SET IT NEGATIVE 
      ADB A         ADD IN THE TEST BOUND 
      SSB,RSS       IS IT BELOW OR EQUAL OR ABOVE?
      JMP ABOVE     EQUAL OR ABOVE, IT'S OK 
* 
      CCA           BELOW, IT'S IN THE RANGE CONFLICT 
      JMP BCHEK,I   RETURN
* 
ABOVE CLB,INB 
OKEX  CLA           OK EXIT 
      JMP BCHEK,I 
* 
BELOW CCB 
      JMP OKEX
      XIF 
      SKP 
* 
*     STORAGE AREA
* 
      IFN           *** L/10 CODE *** 
N1    DEC -1
* 
.2    DEC 2 
.3    DEC 3 
.8    DEC 8 
.9    DEC 9 
.12   DEC 12
.20   DEC 20
* 
B77   OCT 77
B1777 OCT 1777
* 
NULO  NOP           NEW LOW BOUND 
NUHI  NOP           NEW HIGH BOUND
NULOB NOP           NEW BASE PAGE LOW BOUND 
NUHIB NOP           NEW BASE PAGE HIGH BOUND
MLO   NOP           MAIN LOW
MHI   NOP           MAIN HIGH 
BLO   NOP           BASE LOW
BHI   NOP           BASE HIGH 
* 
COUNT NOP           LOOP COUNTER
IDPTR NOP           POINTER TO NAME IN ID SEGMENT 
NUMSG NOP           NUMBER OF SEGMENTS
BNDCK NOP           STORE RESULT OF BCHEK 
AB.BL NOP           STORE ABOVE/BELOW RESULT OF BCHEK 
* 
LO    NOP           LOW BOUNDRY FOR BCHEK 
HI    NOP           HIGH BOUNDARY FOR BCHEK 
* 
FWBG  NOP           NEGATIVE VALUE OF FIRST WORD OF BACKGROUND
      XIF 
* 
A     EQU 0 
B     EQU 1 
* 
END   EQU * 
* 
      END 
                                        