Power-Programmierung

home *** CD-ROM | disk | FTP | other *** search

/ Power-Programmierung / CD1.mdf / assemblr / library / sampler0 / ovlmgr.asm < prev next >

Wrap

Assembly Source File | 1989-11-27 | 30.1 KB | 1,180 lines

; SCCS Id: @(#)ovlmgr.asm 3.0 89/11/16 ; Copyright (c) Pierre Martineau and Stephen Spackman, 1989. ; This product may be freely redistributed. See NetHack license for details. PAGE 60,132 TITLE 'Overlay manager for use with Microsoft overlay linker' SUBTTL 'Brought to you by Pierre Martineau and Stephen Spackman' ; acknowledgements: - No thanks to Microsoft ; - alltrsidsctysti!!! ; - izchak and friends for impetus ; - us for brilliance ; - coffee for speed ; - others as necessary ; assumptions: - all registers are preserved including flags ; - the stack is preserved ; - re-entrancy is not required DOSALLOC equ 48h ; memory allocation DOSFREE equ 49h ; free allocated memory DOSREALLOC equ 4ah ; modify memory block DOSREAD equ 3fh ; read bytes from handle DOSSEEK equ 42h ; logical handle seek DOSOPEN equ 3dh ; open handle DOSCLOSE equ 3eh ; close handle DOSGETVEC equ 35h ; get interrupt vector DOSSETVEC equ 25h ; set interrupt vector DOSEXEC equ 4bh ; exec child process DOS equ 21h ; Dos interrupt # PRINT equ 09h ; print string TERMINATE equ 4ch ; terminate process CR equ 0dh LF equ 0ah BELL equ 07h FAERIE equ 0h ; Used for dummy segment allocation PARSIZ equ 10h ; this is the size of a paragraph - this better not change! ; The following extrns are supplied by the linker extrn $$OVLBASE:byte ; segment of OVERLAY_AREA extrn $$MPGSNOVL:byte ; ^ to module table extrn $$MPGSNBASE:word ; ^ to module segment fixups extrn $$INTNO:byte ; interrupt number to be used extrn $$COVL:word ; number of physical overlays extrn $$CGSN:word ; number of modules extrn $$MAIN:far ; ^ to function main() public $$OVLINIT ; Our entry point ; called by the c startup code ovlflgrec record running:1=0,locked:1=0,loaded:1=0 ; overlay flags ; This is a dirty hack. What we need is a virtual segment that will be built ; by the (our) loader in multiple copies, one per overlay. Unfortunately, this ; doesn't seem to be a sensible idea in the minds of the folks at Microsoft. ; Declaring this segment AT will ensure that it never appears in the exefile, ; and ASSUME is dumb enough to be fooled. ; ; The reason we want to do this is also not-to-be-tried-at-home: it turns out ; that we can code a faster interrupt handler if we map overlay numbers to ; segment values. Normally I would consider this unacceptable programming ; practise because it is 86-mode specific, but the *need* for this entire ; programme is 86-mode specific, anyway. pspseg segment para at FAERIE ; dummy segment for psp org 2ch ; ^ to segment of environmemt in psp pspenv LABEL WORD pspseg ends ovltbl segment para at FAERIE ; Dummy segment definition for overlay table ; NOTE: This segment definition MUST be exactly 16 bytes long ovlflg ovlflgrec <0,0,0> ; overlay flags ovltblpad1 db ? ; go ahead, delete me! ovlmemblk dw ? ; ^ to allocated memory block ovlseg dw 0 ; ovl segment physical add. ovlfiloff dw ? ; ovl file offset in pages (512 bytes) ovlsiz dw ? ; ovl size in paragraphs ovllrudat dd 0 ; misc lru data (pseudo time stamp) ovltblpad2 dw ? ; go ahead, delete me! if1 if $ gt PARSIZ .err %out This segment MUST be no more than 16 bytes, REALLY!!! endif endif ovlsegsiz equ PARSIZ ; this had better be true!!! (16 bytes) ovltbl ends EXEHDR struc ; structure of an EXE header exesign dw 5a4dh ; signature exelstpgesiz dw ? ; last page size (512 byte pages) exesiz dw ? ; total pages (including partial last page) relocitems dw ? ; number of relocation entries hdrparas dw ? ; number of paragraphs in the header minalloc dw ? ; minimum paragraph allocation maxalloc dw ? ; maximum patagraph allocation exess dw ? ; initial stack segment exesp dw ? ; initial stack pointer exechksum dw ? ; checksum exeip dw ? ; initial instruction pointer execs dw ? ; initial code segment reloctbloff dw ? ; offset from beginning of header to relocation table exeovlnum dw ? ; overlay number EXEHDR ends MASK_used equ 1 ; memory block flag memctlblk struc ; memory block structure memblkflg db 0 ; flags memblkpad1 db 0 ; go ahead, delete me! memblknxt dw 0 ; ^ to next block memblkprv dw 0 ; ^ to previous block memblkovl dw 0 ; ^ to overlay occupying this block memblksiz dw 0 ; size in paragraphs memblkpad db PARSIZ - ($ - memblkflg) mod parsiz dup (?) ; pad to 16 bytes memctlblk ends memctlblksiz equ memblkpad + SIZE memblkpad ; should equal 1 paragraph (16 bytes) ;------------------------------------------------------------------------------- code segment public ovlexefilhdl dw -1 ; always-open file handle of our .EXE ovltim dd 0 ; pseudo-lru time variable curovl dw offset framestk ; ^ into stack frame ovlcnt dw 0 ; # overlays modcnt dw 0 ; # of modules ovltblbse dw -1 ; segment of first overlay descriptor ovlrootcode dw 0 ; logical segment of OVERLAY_AREA ovldata dw 0 ; logical segment of OVERLAY_END memblk1st dw 0 ; first memory block pspadd dw 0 ; our psp address + 10h (for relocations) oldvec dd -1 ; saved interrupt vector oldint21 dd -1 ; saved int 21 vector memstat db 0ffh ; must we re-allocate some memory bxreg dw 0 ; temp save area esreg dw 0 ; temp save area farcall dd 0 ; internal trampoline. hdr EXEHDR <> ; EXE header work area hdrsize equ $ - hdr framestk dw 100h dup (0) ; internal stack moduletbl dw 256*2 dup (0) ; module lookup table noroom db CR,LF,'Not enough memory to run this program. Time to go to the store.',CR,LF,BELL,'$' nocore db CR,LF,'Your dog eats all your remaining memory! You die.',CR,LF,BELL,'$' nofile db CR,LF,'The Nymph stole your .EXE file! You die.',CR,LF,BELL,'$' exitmsg db CR,LF,'$' ;------------------------------------------------------------------------------- $$OVLINIT proc far ; Init entry point assume cs:code,ds:pspseg,es:nothing push ax push bx push cx push dx push si push di push bp push ds push es ; save the world mov ax,ds ; get our psp add ax,10h mov pspadd,ax ; save it mov ds,pspenv ; get environment segment mov si,-1 envloop: ; search for end of environment inc si cmp word ptr [si],0 jnz envloop add si,4 ; point to EXE filename mov al,0 ; access code mov ah,DOSOPEN mov dx,si int DOS ; open EXE jnc dontdie mov al,5 mov dx,offset nofile jmp putserr ; cry to the world! dontdie: mov ovlexefilhdl,ax ; save handle mov ax,SEG $$OVLBASE ; OVERLAY_AREA segment mov ovlrootcode,ax ; Now allocate memory mov bx,0900h ; allocate memory for malloc() mov ah,DOSALLOC int DOS jnc getmore jmp buyram getmore: mov es,ax ; find largest free memory mov ah,DOSALLOC mov bx,0ffffh ; Everything int DOS mov ah,DOSALLOC ; allocate our own memory int DOS jnc gotitall jmp buyram gotitall: mov memstat,0 ; indicate that we have memory mov ovltblbse,ax ; overlay descriptor table begins at start of memory block mov ax,SEG $$COVL ; segment of DGROUP mov ds,ax mov cx,$$CGSN ; number of modules mov modcnt,cx ; save for later use mov cx,$$COVL ; number of physical overlays mov ovlcnt,cx ; save for later use sub bx,cx ; enough mem for ovl tbl? jnc memloop jmp buyram memloop: push bx mov ah,DOSFREE ; free first block for malloc() int DOS jnc cockadoodledoo jmp buyram cockadoodledoo: assume es:ovltbl xor bp,bp xor di,di xor si,si filsegtbllpp: ; initialise ovl table call gethdr ; get an EXE header mov ax,ovltblbse add ax,hdr.exeovlnum mov es,ax ; ^ to ovl table entry xor ax,ax mov word ptr ovllrudat,ax ; initialise ovl lru mov word ptr ovllrudat+2,ax mov ovlseg,ax ; initialise ovl segment mov ovlflg,al ; initialise ovl flags mov ax,hdr.exesiz shl ax,1 shl ax,1 shl ax,1 shl ax,1 shl ax,1 ; * 32 mov dx,hdr.exelstpgesiz or dx,dx jz emptypage shr dx,1 shr dx,1 shr dx,1 shr dx,1 ; / 16 inc dx sub ax,20h add ax,dx emptypage: mov ovlsiz,ax ; overlay size in paragraphs sub ax,hdr.hdrparas ; actual size of code and relocation table cmp hdr.exeovlnum,0 ; skip if ovl 0 (root code) jz notlargest cmp ax,di ; find largest ovl jc notlargest mov di,ax mov si,ovlsiz notlargest: mov ovlfiloff,bp ; initialise ovl file offset add bp,hdr.exesiz ; ^ to next overlay mov dx,bp mov cl,dh mov dh,dl xor ch,ch xor dl,dl shl dx,1 rcl cx,1 ; cx:dx = bp * 512 mov al,0 mov ah,DOSSEEK ; seek to next ovl int DOS mov ax,ovlcnt dec ax cmp ax,hdr.exeovlnum ; all overlays done? jz makmemblk jmp filsegtbllpp ; Nope, go for more. makmemblk: push si ; contains largest ovl size in paragraphs assume es:nothing ; prepare first two memory blocks ; OVERLAY_AREA and allocated memory block mov ax,ovlrootcode ; OVERLAY_AREA segment mov es,ax mov si,ovltblbse add si,ovlcnt ; end of ovl table mov es:memblkflg,0 ; clear mem flags mov es:memblknxt,si ; point to next mov es:memblkprv,0 ; set previous to nothing mov es:memblksiz,di ; di contains OVERLAY_AREA size in paragraphs add di,ax mov ovldata,di ; end of OVERLAY_END mov es,si ; end of ovl tbl (first memory block in allocated memory) mov es:memblkflg,0 ; clear mem flags mov es:memblknxt,0 ; set next to nothing mov es:memblkprv,ax ; point to previous pop si pop bx mov es:memblksiz,bx ; allocated memory block size less ovl table mov memblk1st,ax ; save pointer to first mem block mov word ptr ovltim,0 ; initialise global lru time stamp mov word ptr ovltim+2,0 mov ax,offset framestk mov curovl,ax ; initialise stack frame pointer mov di,ax mov word ptr cs:[di],-1 ; initialise stack frame add di,6 mov ax,ovltblbse mov cs:[di],ax mov curovl,di mov es,ax mov es:ovlflg,MASK running OR MASK locked OR MASK loaded ; set flags on ovl 0 inc si ; largest ovl size + 1 paragraph cmp bx,si ; enough memory to alloc largest? jnc chgintvec buyram: mov al,5 mov dx,OFFSET noroom ; free up some TSRs or something jmp putserr chgintvec: mov ax,SEG $$INTNO mov ds,ax mov ah,DOSGETVEC mov al,$$INTNO ; get int number to use int DOS ; get original vector mov word ptr oldvec,bx ; save original vector mov word ptr oldvec+2,es mov ah,DOSGETVEC mov al,21h int DOS ; get original vector mov word ptr oldint21,bx ; save original vector mov word ptr oldint21+2,es mov ax,SEG $$INTNO mov ds,ax mov ah,DOSSETVEC mov al,$$INTNO mov bx,cs mov ds,bx mov dx,OFFSET ovlmgr ; point to ovlmgr int DOS ; set vector mov ah,DOSSETVEC mov al,21h mov bx,cs mov ds,bx mov dx,OFFSET int21 ; point to int21 int DOS ; set vector mov cx,modcnt ; module count mov ax,SEG $$MPGSNBASE mov es,ax mov ax,cs mov ds,ax assume ds:code mov bx,offset $$MPGSNBASE ; ^ to linker provided overlay segment fixups mov si,offset $$MPGSNOVL ; ^ to linker provided module table mov di,offset moduletbl ; ^ to our module table modloop: mov al,es:[si] ; real physical ovl number xor ah,ah add ax,ovltblbse ; ovlctlseg address mov [di],ax ; save in module table mov ax,es:[bx] ; get seg fixup sub ax,ovlrootcode ; adjust for relative reference mov [di+2],ax ; save in module table add di,4 add bx,2 inc si loop modloop pop es pop ds pop bp pop di pop si pop dx pop cx pop bx pop ax ; restore the world jmp $$MAIN ; And away we go! $$OVLINIT endp ;------------------------------------------------------------------------------- ovlmgr proc far ; This the it! assume cs:code,ds:nothing,es:nothing mov bxreg,bx ; preserve bx mov esreg,es ; and es pop bx ; retrieve caller ip pop es ; " " cs push ax push si mov ax,es:[bx+1] ; offset in ovl to call mov word ptr farcall,ax ; into trampoline xor ah,ah mov al,es:[bx] ; module # to call add bx,3 ; fix return address mov si,curovl ; get stack frame pointer mov cs:[si+2],es ; save return seg mov cs:[si+4],bx ; and return offset mov bx,ax shl bx,1 shl bx,1 ; * 4 (2 words/entry in module tbl) add bx,offset moduletbl mov es,cs:[bx] ; ovl tbl entry mov ax,cs:[bx+2] ; segment fixup mov cs:[si+6],es ; ovl entry into stack frame add curovl,6 ; update stack assume es:ovltbl mov si,WORD PTR ovltim ; lru time stamp inc si ; time passes! mov WORD PTR ovltim,si ; update global clock mov WORD PTR ovllrudat,si ; as well as ovl clock jz ininc ; dword increment cryupcdon: test ovlflg,mask loaded ; ovl loaded? jz inload ; load it then. ovlloadedupc: add ax,ovlseg ; add fixup and segment address mov word ptr farcall+2,ax ; into trampoline mov bx,bxreg ; retore all registers mov es,esreg pop si pop ax popf ; don't forget these! call DWORD PTR farcall ; and GO pushf ; preserve registers again! mov esreg,es mov bxreg,bx mov bx,curovl ; stack frame pointer mov es,cs:[bx-6] ; retrieve ovl tbl entry push cs:[bx-4] ; set return address push cs:[bx-2] push cx mov cx,WORD PTR ovltim ; do the lru thing again inc cx mov WORD PTR ovltim,cx mov WORD PTR ovllrudat,cx jz outinc crydncdon: test ovlflg,mask loaded ; ovl loaded? jz outload ; better get it before someone notices jmpback: sub curovl,6 ; adjust stack mov bx,bxreg ; get registers back mov es,esreg pop cx iret ; and GO back ininc: mov si,WORD PTR ovltim+2 ; high word of lru inc si mov WORD PTR ovltim+2,si ; update global and mov WORD PTR ovllrudat+2,si ; ovl clocks jmp cryupcdon inload: call loadoverlay ; self explanatory jmp ovlloadedupc outinc: mov cx,WORD PTR ovltim+2 inc cx mov WORD PTR ovltim+2,cx mov WORD PTR ovllrudat+2,cx jmp crydncdon outload: call loadoverlay jmp jmpback ovlmgr endp ;------------------------------------------------------------------------------- loadoverlay proc near ; load overlay pointed to by es assume cs:code,ds:nothing,es:ovltbl push ax push bx push cx push dx push si push di push bp push ds push es ; just in case cmp memstat,0 jz dontrealloc call reallocmem dontrealloc: call setrunning ; set the running flags test ovlflg,MASK running ; was it already running? jnz fxdadr ; Yup, it's a toughie mov ax,ovlsiz ; How much? call getpages ; never fail mem alloc, you bet. jmp gleaner fxdadr: call releasepages ; free memory where this ovl should be loaded gleaner: mov ovlmemblk,ax ; memory block to use add ax,memctlblksiz / PARSIZ; skip mem ctl blk mov ds,ax mov dx,ovlfiloff ; where in the file is it? mov cl,dh mov dh,dl xor ch,ch xor dl,dl shl dx,1 rcl cx,1 ; cx:dx = dx * 512 mov ah,DOSSEEK ; lseek to position mov al,0 mov bx,ovlexefilhdl ; never closing handle int DOS jc burnhead ; oops! xor dx,dx mov cx,ovlsiz ; number of paragraphs to load shl cx,1 shl cx,1 shl cx,1 shl cx,1 ; * 16 = number of bytes mov ah,DOSREAD ; prevent random DOS behaviour int DOS jc burnhead ; double oops! call ovlrlc ; perform relocation normally done by DOS EXE loader pop es ; retrieve ovl tbl entry or ovlflg,MASK loaded ; because it is now pop ds pop bp pop di pop si pop dx pop cx pop bx pop ax ret burnhead: mov al,5 mov dx,offset nofile jmp putserr loadoverlay endp ;------------------------------------------------------------------------------- ovlrlc proc near ; ds:0 -> the overlay to relocate assume cs:code,ds:nothing,es:ovltbl mov cx,ds:relocitems ; roto-count mov ax,ds add ax,ds:hdrparas ; skip header mov ovlseg,ax ; actual code starts here mov di,ax sub di,ovlrootcode ; segment fixup value mov si,ds:reloctbloff ; ^ relocation tbl in header jcxz relocdone ; not such a good idea, after all dorelocs: ; labels don't GET comments lodsw ; offset into load module mov bx,ax lodsw ; segment in load module (zero reference) add ax,pspadd ; now it is psp relative add ax,di ; and now it is relative to the actual load address mov es,ax mov ax,es:[bx] ; pickup item to relocate add ax,pspadd ; make it psp relative cmp ax,ovlrootcode ; is it below the OVERLAY_AREA? jc reloccomputed ; yup. it's relocated cmp ax,ovldata ; is it above OVERLAY_AREA jnc reloccomputed ; yup. it's relocated add ax,di ; it's in OVERLAY_AREA, this one's ours. reloccomputed: mov es:[bx],ax ; RAM it home!?! loop dorelocs ; what goes around, comes around. relocdone: ret ovlrlc endp ;------------------------------------------------------------------------------- getvictim proc near ; select a victim to discard (and free up some memory) assume cs:code,ds:ovltbl,es:nothing push bx push cx push dx push si push di push bp push ds mov ds,ovltblbse ; ^ ovl tbl xor ax,ax ; will contain the low word of lru mov dx,ax ; will contain the high word of lru mov bp,ax ; will contain ovl tbl entry mov bx,ax ; ovl tbl ptr ; mov cx,ovlcnt ; number of ovl's to scan ;foon: test ovlflg[bx],MASK loaded ; is this one loaded? ; jz skip ; nope, try next one ; test ovlflg[bx],MASK locked ; is this one loacked? ; jnz skip ; yup, try next one ; test ovlflg[bx],MASK running ; is this one running? ; jnz skip ; yup, try next one ; mov si,WORD PTR ovltim ; get global lru ; mov di,WORD PTR ovltim+2 ; sub si,WORD PTR ovllrudat[bx] ; subtract from ovl lru ; sbb di,WORD PTR ovllrudat[bx+2] ; cmp dx,di ; is this one older? ; jc better ; it sure is ; jnz skip ; it definitely isn't ; cmp ax,si ; jnc skip ; it really isn't ;better: mov ax,si ; save the lru stuff and ovl ptr ; mov dx,di ; mov bp,bx ;skip: add bx,ovlsegsiz ; do next ovl ; loop foon ; or bp,bp ; did we find anyone to kill? ; jnz gotvictim ; yes we did, partner. ; xor bx,bx ; Oh well, do it again disregarding the running flag mov cx,ovlcnt foon1: test ovlflg[bx],MASK loaded jz skip1 test ovlflg[bx],MASK locked jnz skip1 mov si,WORD PTR ovltim mov di,WORD PTR ovltim+2 sub si,WORD PTR ovllrudat[bx] sbb di,WORD PTR ovllrudat[bx+2] cmp dx,di jc better1 jnz skip1 cmp ax,si jnc skip1 better1: mov ax,si mov dx,di mov bp,bx skip1: add bx,ovlsegsiz loop foon1 or bp,bp ; were we more successful this time? jnz gotvictim ; now we got one. nomoremem: mov al,5 ; were really %$# now! mov dx,offset nocore jmp putserr gotvictim: shr bp,1 ; convert offset to segment shr bp,1 shr bp,1 shr bp,1 mov ax,ds add ax,bp pop ds pop bp pop di pop si pop dx pop cx pop bx ret getvictim endp ;------------------------------------------------------------------------------- setrunning proc near ; set running flag on overlays still running assume cs:code,ds:nothing,es:ovltbl push es mov es,ovltblbse mov cx,ovlcnt xor bx,bx jim: and ovlflg[bx],NOT MASK running ; start by clearing them all add bx,ovlsegsiz loop jim ; Now chain down the stack links, setting running flags mov bx,curovl sub bx,6 jmp jam jamloop: mov ds,cs:[bx] assume ds:ovltbl or ovlflg,MASK running sub bx,6 jam: cmp word ptr cs:[bx],-1 ; end of stack ? jnz jamloop pop es ret setrunning endp ;------------------------------------------------------------------------------- int21 proc near ; free almost all overlay memory if app. tries to call the DOS exec function. cmp ah,DOSEXEC jz freeall cmp ah,TERMINATE jz saybyebye jmp cs:oldint21 saybyebye: pop ax ; clean up stack pop ax pop ax mov al,0 ; return code 0 mov dx,offset exitmsg jmp putserr freeall: push ax push bx push cx push dx push si push di push bp push es push ds ; preserve calling env. assume cs:code,ds:nothing,es:ovltbl mov ax,cs:memblk1st ; start de-allocating from first blk jmp short lastblk unloadlp: mov ds,ax cmp ax,cs:ovltblbse ; in alloced area ? jc nextmemblk test ds:memblkflg,MASK_used ; mem blk used ? jz nextmemblk mov es,ds:memblkovl and ovlflg,NOT MASK loaded ; flag overlay as unloaded nextmemblk: mov ax,ds:memblknxt lastblk: or ax,ax ; keep going till no more jnz unloadlp mov ax,cs:ovltblbse add ax,cs:ovlcnt mov es,ax ; ^ to first mem blk in alloced mem mov es:memblksiz,2 ; adjust size mov es:memblknxt,0 ; no other blocks after this one mov es:memblkflg,0 ; not used mov cs:memstat,0ffh ; memory needs to be re-alloced some day mov dx,word ptr cs:oldint21 mov ds,word ptr cs:oldint21+2 mov ah,DOSSETVEC ; put back DOS vector to avoid calling ourselves again! mov al,21h int DOS mov es,cs:ovltblbse mov bx,cs:ovlcnt add bx,2 ; re-adjust alloced size mov ah,DOSREALLOC int DOS pop ds pop es pop bp pop di pop si pop dx pop cx pop bx pop ax jmp cs:oldint21 ; allow DOS to continue! int21 endp ;------------------------------------------------------------------------------- reallocmem proc near ; re-allocate our memory after a DOS exec function push es mov ah,DOSREALLOC mov es,cs:ovltblbse ; mem blk handle mov bx,0ffffh ; find out how much there is int DOS mov ah,DOSREALLOC ; re-allocate our own memory mov es,cs:ovltblbse push bx ; contains largest available blk int DOS mov cs:memstat,0 ; flag it re-alloced mov ax,cs:ovltblbse add ax,cs:ovlcnt mov es,ax ; ^ to first mem blk in alloced mem pop ax sub ax,cs:ovlcnt ; remove ovl rbl size mov es:memblksiz,ax ; fix mem blk size mov ah,DOSGETVEC mov al,21h int DOS ; get original vector mov word ptr cs:oldint21,bx ; save original vector mov word ptr cs:oldint21+2,es mov ah,DOSSETVEC mov al,21h mov bx,cs mov ds,bx mov dx,OFFSET int21 ; point to int21 int DOS ; set vector pop es ret reallocmem endp ;------------------------------------------------------------------------------- releasepages proc near ; Arg in es, result in ax ; release any memory (and overlays) where this overlay should reside assume es:ovltbl mov bx,es:ovlmemblk ; start of memory to release doitagain: mov ax,memblk1st ; first memory blk jmp dvart dvartloop: mov ds,ax ; memory blk to check cmp bx,ax ; does it start below the memory to release? jnc dvartsmaller ; yup mov dx,bx add dx,es:ovlsiz add dx,memctlblksiz / PARSIZ; end of memory to release cmp ax,dx ; does it start above? jnc dvartsilly ; yup call killmem ; it's in the way. Zap it. jmp chkmemblk dvartsmaller: add ax,ds:memblksiz ; end of this memory blk cmp bx,ax ; does it end below the memory to release? jnc dvartsilly ; yup call killmem ; Oh well, zap it too. chkmemblk: ; was that enough? mov ax,ds ; recently freed memory blk cmp bx,ax ; does it start in the memory to be released? jc dvartsilly ; yup, wasn't enough mov dx,bx add dx,es:ovlsiz add dx,memctlblksiz / PARSIZ; end of memory to be released add ax,ds:memblksiz ; end of freed memory cmp ax,dx ; does it end in the memory to be released? jc dvartsilly ; yup, release more dvartgotblk: mov ax,ds ; this is it! mov cx,bx sub cx,ax ; # of paragraphs between start of memory to release and mem blk jz nosplit call splitblkhigh ; split the block nosplit: mov cx,es:ovlsiz add cx,memctlblksiz / PARSIZ; paragraphs needed to load ovl jmp splitblklow ; split remaining block dvartsilly: mov ax,ds:memblknxt dvart: or ax,ax ; enf of mem list? jz dvartnocore jmp dvartloop ; play it again Sam. dvartnocore: mov al,5 ; super OOPS! mov dx,offset nocore jmp putserr releasepages endp ;------------------------------------------------------------------------------- getpages proc near ; get enough memory to load ovl mov cx,ax add cx,memctlblksiz / PARSIZ; total paragraphs needed call largestmem ; find largest free blk cmp dx,cx ; large enough? jnc gotdork ; yup. dorkkill: call getvictim ; select a victim to release call killovl ; kill the selected victim cmp ds:memblksiz,cx ; was it enough? jc dorkkill ; nope, select another one gotdork: jmp splitblklow ; split the free blk getpages endp ;------------------------------------------------------------------------------- splitblklow proc near ; split a block of memory returning the lower one to be used. push es or ds:memblkflg,MASK_used ; set low block used mov ax,ds add ax,cx mov es,ax ; ^ to upper blk to be created mov ax,ds:memblksiz sub ax,cx cmp ax,1 ; must be at least 1 para remaining to split jc noodorksplit ; don't split mov ds:memblksiz,cx ; fix blk sizes mov es:memblksiz,ax mov ax,ds:memblknxt ; fix pointers mov es:memblknxt,ax mov ds:memblknxt,es mov es:memblkprv,ds mov es:memblkflg,0 ; set upper to not used push ds mov ax,es:memblknxt or ax,ax jz domergelow mov ds,ax ; fix blk after upper to point to upper mov ds:memblkprv,es domergelow: mov ax,es mov ds,ax call mergemem ; merge remaining free memory pop ds noodorksplit: pop es mov ds:memblkovl,es ; fix ptr to ovl mov ax,ds ; return lower blk segment ret splitblklow endp ;------------------------------------------------------------------------------- splitblkhigh proc near ; split a block of memory returning the upper one to be used. push es mov ax,ds add ax,cx mov es,ax ; ^ to upper blk to be created mov ax,ds:memblksiz sub ax,cx ; # of para remaining in upper blk mov ds:memblksiz,cx ; fix blk sizes mov es:memblksiz,ax mov ax,ds:memblknxt ; fix blk pointers mov es:memblknxt,ax mov ds:memblknxt,es mov es:memblkprv,ds mov ds:memblkflg,0 ; set lower to not used or es:memblkflg,MASK_used ; set upper to used mov ax,es:memblknxt or ax,ax jz domergehigh push ds ; fix blk after upper to point to upper mov ds,ax mov ds:memblkprv,es pop ds domergehigh: call mergemem ; merge remaining free memory nodorksplit: mov ax,es mov ds,ax pop es mov ds:memblkovl,es ; fix ovl ptr mov ax,ds ; return upper blk segment ret splitblkhigh endp ;------------------------------------------------------------------------------- largestmem proc near ; returns seg in ax, size in dx; clobbers bx,ds,es ; retruns first block that's large enough if possible mov ax,memblk1st ; first mem blk xor dx,dx ; largest size found jmp gook gookloop: mov ds,ax test ds:memblkflg,MASK_used ; is this blk used? jnz gookme ; yup cmp ds:memblksiz,cx ; is it large enough? jc gookme ; nope mov dx,ds:memblksiz ; got one! ret gookme: mov ax,ds:memblknxt gook: or ax,ax ; end of list? jnz gookloop ; around and around ret largestmem endp ;------------------------------------------------------------------------------- killmem proc near test ds:memblkflg,MASK_used ; is it used? jz memnotused ; don't kill ovl push es mov es,ds:memblkovl and es:ovlflg,NOT MASK loaded ; zap ovl associated with this blk pop es memnotused: jmp mergemem ; merge free memory killmem endp ;------------------------------------------------------------------------------- killovl proc near ; preserves bx mov ds,ax assume ds:ovltbl and ovlflg,NOT MASK loaded ; ovl no longer loaded mov ax,ovlmemblk ; get mem blk mov ds,ax jmp mergemem ; merge free memory killovl endp ;------------------------------------------------------------------------------- mergemem proc near ; merge physically adjacent free memory blocks. Preserves es. ds -> a free block. push es and ds:memblkflg,NOT MASK_used ; set current free mov ax,ds:memblkprv ; get previous blk or ax,ax ; was there a previous blk? jz gibber ; nope mov es,ax test es:memblkflg,MASK_used ; is the previous blk used? jnz gibber ; yup add ax,es:memblksiz ; end of previous blk mov dx,ds cmp dx,ax ; physically adjacent? jnz gibber ; nope mov ax,ds:memblksiz add es:memblksiz,ax ; adjust size of new larger blk mov ax,ds:memblknxt ; fix pointers mov es:memblknxt,ax or ax,ax jz almostgibber mov ds,ax ; fix pointer of next blk mov ds:memblkprv,es almostgibber: mov ax,es mov ds,ax ; new blk segment gibber: mov ax,ds:memblknxt ; get next blk or ax,ax ; was there a next blk? jz killdone ; nope mov es,ax test es:memblkflg,MASK_used ; is the nxt blk used? jnz killdone ; yup mov ax,ds add ax,ds:memblksiz ; end of this blk mov dx,es cmp ax,dx ; physically adjacent? jnz killdone ; nope mov ax,es:memblksiz add ds:memblksiz,ax ; adjust size of new larger blk mov ax,es:memblknxt ; fix pointers mov ds:memblknxt,ax or ax,ax jz killdone mov es,ax ; fix pointer of blk after nxt mov es:memblkprv,ds killdone: and ds:memblkflg,NOT MASK_used ; make sure it's free pop es ret mergemem endp ;------------------------------------------------------------------------------- gethdr proc near ; read EXE header from handle push cx mov ax,cs mov ds,ax mov dx,offset hdr ; a place to put it mov bx,ovlexefilhdl ; the file handle mov cx,hdrsize ; header size in bytes mov ah,DOSREAD int DOS ; read from file jc exegone ; oops cmp ax,cx ; got correct number of bytes? jnz exegone ; nope pop cx ret ; Wow, it worked! exegone: mov al,5 ; You lose! mov dx,offset nofile jmp putserr gethdr endp ;------------------------------------------------------------------------------- putserr proc near ; display error msg, close file, restore int vectors, free mem and return to DOS. push ax ; keep return code for later mov ax,cs mov ds,ax mov ah,PRINT int DOS ; display error msg mov dx,word ptr oldvec ; get old vector cmp dx,-1 ; was it ever replaced? jz free21 ; nope push ds mov ds,word ptr oldvec+2 mov ah,DOSSETVEC ; put it back then. mov al,$$INTNO int DOS pop ds free21: mov dx,word ptr oldint21 cmp dx,-1 jz freemem push ds mov ds,word ptr oldint21+2 mov ah,DOSSETVEC ; put it back then. mov al,21h int DOS pop ds freemem: mov ax,ovltblbse ; get memory blk segment cmp ax,-1 ; was one ever allocated? jz closefile ; nope mov es,ax mov ah,DOSFREE ; must free it. int DOS closefile: mov bx,ovlexefilhdl ; get file handle cmp bx,-1 ; was the file ever opened? jz byebye ; nope mov ah,DOSCLOSE ; close it int DOS byebye: pop ax ; return code in al mov ah,TERMINATE int DOS ; terminate this process putserr endp code ends end