title asmhelp - assembler helpers
page ,132
;--------------------------------------------------------------------
;
; asmhelp fast assembly language helpers for masm
;
; (C)Copyright 1985 Microsoft Corp.
;
; Revision history
;
; 04/02/85 Greg Whitten
; initial version
; scanatom speedups
;
;--------------------------------------------------------------------
ifndef MSDOS
ifndef CPDOS
.286
endif
endif
.model medium,c
if1
alignCode macro
align 4
endm
.xlist
include mixed.inc
.list
.lall
endif
cLang = 1
CASEL = 1
SYMMAX = 31
TSYMSIZE = 451 ; from asmsym.c
LEGAL1ST = 08h ; legal 1st token character mask
TOKLEGAL = 10h ; legal token character mask
.code A_TEXT
extrn Pascal ERRORC:near
extrn Pascal CREFNEW:far
extrn Pascal CREFOUT:far
extrn Pascal OFFSETASCII:far
extrn Pascal listline:far
extrn Pascal crefline:far
extrn Pascal tryOneFile:far
extrn _ffree:far
ifndef MSDOS
extrn read:proc
extrn write:proc
extrn lseek:proc
extrn free:proc
endif
ifdef CPDOS
extrn Pascal DosRead:far
extrn Pascal DosChgFilePtr:far
extrn Pascal DosWrite:far
endif
.data
extrn _asmctype_:byte
extrn _asmcupper_:byte
extrn _asmTokenMap_:byte
extrn caseflag:byte
extrn fCrefline:byte
extrn fNeedList:byte
extrn objing:byte
extrn srceof:byte
extrn crefing:byte
extrn emitrecordtype:byte
extrn linebp:word
extrn linelength:byte
extrn linebuffer:byte
extrn linessrc:word
extrn listconsole:byte
extrn begatom:word
extrn endatom:word
extrn errorlineno:word
extrn errorcode:word
extrn oOMFCur:dword
extrn handler:byte
extrn lbufp:word
extrn pass2:byte
extrn save:byte
extrn svname:word
extrn obj:word
extrn pFCBCur:word
extrn naim:word
extrn objerr:word
extrn objectascii:word
extrn iProcCur:word
extrn symptr:dword
extrn lsting:byte
extrn lbuf:byte
ifdef BCBOPT
extrn hash:word
extrn lcname:word
extrn svhash:word
extrn svlcname:word
extrn fNoCompact:byte
endif
@CurSeg ends
assume ds:nothing
extrn tsym:dword
assume ds:@data
.data?
mapstr db 10 dup(?) ; use this if /Ml
ifdef M8086OPT
qlcname db SYMMAX+1 dup(?)
dw 1 dup(?) ;hash for name
db 1 dup(?) ;cb for name
qname db SYMMAX+1 dup(?)
qsvlcname db SYMMAX+1 dup(?)
dw 1 dup(?) ;hash for name
db 1 dup(?) ;cb for name
qsvname db SYMMAX+1 dup(?)
endif
ifdef M8086OPT
public qlcname, qname, qsvlcname, qsvname
endif
.data
fEatBlanks db 1 ; flag for common getatom & getatomend
cbLeft dw 0 ; count of bytes left in lbuf
rarea dw 0 ; area for DosRead/Write to tell how much it read
.code A_TEXT
ifdef M8086OPT
;*** getatom () ( hash = scanatom() )
nulToken:
mov lbufp,si ; update buffer pointer
mov [di+SYMMAX+4],bh
pop di
pop si
retn
getatomComm:
hProc <getatom near>, <uses si di>
mov ax,ds
mov es,ax
mov di,lbufp
mov ax,0920H ; load tab|space into AX
or cx,0FFFFH ; large count to CX
alignCode
skipbeg:
repe scasb ; look for space
xchg al,ah
dec di
repe scasb ; then tab
dec di
cmp byte ptr [di],ah
je skipbeg ; repeat if still space
xor ax,ax
xor bx,bx
mov si,di
mov di,lcname
mov bl,[si]
test byte ptr _asmctype_[bx],LEGAL1ST
jz nulToken
xor dx,dx ; initial hash value
mov cx,SYMMAX
mov begatom,si ; start of atom
cmp bl,'.' ;special case for token starting
jne notDot ;with .
inc si
dec cx
mov al,bl
mov dx,ax
stosb
mov [di+SYMMAX+3],al
notDot:
mov bx,offset _asmTokenMap_ ; character translation table
cmp caseflag,CASEL
je short tokloop ; Mu or Mx - use MAP version
alignCode
Mtokloop:
rept 3
lodsb ; al = get next character
stosb ; *lcname++ = cc
xlat
mov [di+SYMMAX+3],al ; *naim++ = cc
add dx,ax ; swapped hash += MAP(cc)
dec cx
or al,al
jz short tokdone
jcxz skiptok
endm
lodsb
stosb
xlat
mov [di+SYMMAX+3],al
add dx,ax
or al,al
loopnz Mtokloop
jz tokdone
jmp skiptok
tokloop:
rept 3
lodsb ; al = get next character
stosb ; *lcname++ = cc
mov [di+SYMMAX+3],al ; *naim++ = cc
xlat
add dx,ax ; swapped hash += MAP(cc)
dec cx
or al,al
jz short tokdone0
jcxz skiptok
endm
lodsb
stosb
mov [di+SYMMAX+3],al
xlat
add dx,ax
or al,al
loopnz tokloop
jz tokdone0
jmp short skiptok
tokdone0:
mov [di+SYMMAX+3],al ; terminate
tokdone:
mov [di-1],al
dec si
mov endatom,si
jmp short skipend
skiptok:
dec cx
skipnext:
lodsb ; eat extra characters in token
xlat
or al,al
jnz skipnext ; skip token
mov endatom,si
mov [di],al
inc di
mov [di+SYMMAX+3],al ; terminate
dec si
skipend: ; skip for getatom only
mov bx,cx
mov di,si
cmp fEatBlanks,0
jz noEatSemie
mov ax,0920H ; load tab|space into AX
or cx,0FFFFH ; large count to CX
alignCode
skipend1:
repe scasb ; look for space
xchg al,ah
dec di
repe scasb ; then tab
dec di
cmp byte ptr [di],ah
je skipend1 ; repeat if still space
skipend2: ; skip trailing white space
mov lbufp,di ; update buffer pointer
xor ax,ax
mov al,SYMMAX-1 ; compute token length
sub al,bl
mov bx,naim
mov byte ptr [bx-1],al ; save prefixed cb
mov word ptr [bx-3],dx ; save prefixed hash
hRet
noEatSemie:
mov fEatBlanks,1
jmp skipend2
hEndp
;*** getatomend () ; get an token without skiping trailing spaces
hProc <getatomend near>
mov fEatBlanks,0
jmp getatomComm
hEndp
endif ;M8086OPT
ifdef M8086OPT
;*** inset (value, setptr)
hProc <inset near>, <uses si di>, value:byte, setptr:word
mov ax,ds
mov es,ax
cld
mov al,value
mov di,setptr
mov cl,[di]
inc di
xor ch,ch ; cx = set length
repne scasb ; scan for al in es:di
je insetT ; yes - return TRUE
xor ax,ax ; return FALSE
insetexit:
hRet
insetT: mov ax,1 ; return TRUE
jmp short insetexit
hEndp
endif ;M8086OPT
;*** strffcmp (far1, far2)
hProc <strffcmp far>, <uses si di>, far1:dword, far2:dword
cld
les di,far2
lds si,far1
mov bx,di ; save start of string
cmpsb ; fast 1st char check
jnz ffne
dec si
xor ax,ax ; search for 0 terminator
mov cx,-1
repne scasb
neg cx ; cx = byte count for compare
mov di,bx
repz cmpsb
ffne: mov al,[si-1]
sub al,es:[di-1] ; ax = 0 if equal
cbw
push ss
pop ds
hRet
hEndp
;*** strnfcmp (near1, far2)
hProc <strnfcmp near>, <uses di si>, near1:word, far2:dword
cld
mov si,near1
les di,far2
mov bx,di ; save start of string
cmpsb ; fast check on 1st character
jnz nfne
dec si
xor ax,ax ; search for 0 terminator
mov cx,-1
repne scasb
neg cx ; cx = byte count for compare
mov di,bx
repz cmpsb
nfne: mov al,[si-1]
sub al,es:[di-1] ; ax = 0 if equal
hRet
hEndp
ifdef M8086OPT
;*** switchname ()
hProc <switchname near>
alignCode
mov ax,naim ;; (naim) <--> (svname)
xchg ax,svname
mov naim,ax
mov ax,lcname ;; (lcname) <--> (svlcname)
xchg ax,svlcname
mov lcname,ax
hRet
hEndP
endif ;M8086OPT
ifdef M8086OPT
;*** I/O routines: readmore, getline, ebuffer, etc.
objfile struc
ofh dw ?
ifdef MSDOS
pos dd ?
buf dd ?
else
pos dw ?
buf dw ?
endif ;MSDOS
cnt dw ?
siz dw ?
oname dw ?
objfile ends
endif ;M8086OPT
ifdef M8086OPT
;*** ebuffer - write out object buffer
;
; ebuffer (rectype, bufpos, buffer)
ebyte macro
dec [bx].cnt
jge short $+5
call edump ; dump buffer
stosb
add ah,al
endm
hProc <ebuffer near>, <uses si di>, rectype:byte, bufpos:word, buffer:word
mov si,buffer
mov cx,bufpos
sub cx,si ; cx = buffer count
jz ebufdone
cmp objing,0
je ebufdone ; return if no object file
mov ax,cx
add ax,4
add word ptr oOMFCur,ax ; oOMFCur += cbBuffer + 3
adc word ptr oOMFCur.2,0
ifndef MSDOS
mov ax,ds
mov es,ax
endif
cld
xor ax,ax ; ah = 0 (initial checksum)
mov al,rectype
mov bx,OFFSET obj ; bx = obj file data structure pointer
ifdef MSDOS
les di,[bx].pos ; es:di = output buffer position
else
mov di,[bx].pos ; di = output buffer position
endif
ebyte ; output record type
inc cx ; + 1 for record length
mov al,cl
ebyte
mov al,ch
ebyte ; output record length
dec cx ; - 1 for buffer loop
alignCode
ebufloop: ; output buffer
lodsb
ebyte
loop ebufloop
mov al,ah ; output checksum
neg al
ebyte
ifdef MSDOS
mov word ptr [bx].pos,di ; reset buffer position
else
mov [bx].pos,di ; reset buffer position
endif
ebufdone:
mov emitrecordtype,0
hRet
hEndp
; edump
;
; Save:
; bx = obj file descriptor pointer
; ax = (checksum,outputbyte)
; cx = possible count
; si = emit buffer position
edump: push ax
push cx
push bx ; save src file descriptor pointer
ifdef MSDOS
push ds
mov cx,[bx].siz
mov ax,[bx].ofh
lds dx,[bx].buf
mov bh,40h
xchg ax,bx
ifdef CPDOS
push bx ; file handle
push ds ; buffer (selector)
push dx ; buffer (offset)
push cx ; # bytes to read
mov ax,@data
push ax ; reply area (selector)
mov ax,offset rarea
push ax ; reply area (offset)
call DosWrite
else
int 21h
endif
pop ds
ifdef CPDOS
or ax,ax
mov ax,rarea
jnz writerr
else
jc writerr
endif
pop bx
push bx
cmp ax,[bx].siz
je writeok
writerr:
mov objerr,-1
writeok:
else
push [bx].siz
push [bx].buf
push [bx].ofh
call write ; write (ofh,buf,siz)
add sp,6
pop bx ; need to get bx back.
push bx ; write trashes it. -Hans
cmp ax,[bx].siz
je writeok
mov objerr,-1
writeok:
mov ax,ds
mov es,ax
cld ; in case
endif
pop bx
mov ax,[bx].siz
dec ax
mov [bx].cnt,ax ; reset buffer position
ifdef MSDOS
mov di,word ptr [bx].buf ; di = start of buffer
else
mov di,[bx].buf ; di = start of buffer
endif
pop cx
pop ax
ret
endif ;M8086OPT
hProc <fMemcpy near>, <uses si di>, pDest:dword, pSource:dword, cb:word
mov cx,cb
jcxz fM1
mov dx,ds
lds si,pSource
les di,pDest
shr cx,1
rep movsw
jnc fM01
movsb
fM01:
mov ds,Dx
fM1:
hRet
hEndp
ifdef M8086OPT
; Native code version of symsrch as in asmsym.c
hProc <symsrch near>, <uses si di>
mov si,naim
xor Dx,Dx
cmp byte ptr[si-1],dl
jne sy001
jmp sy99
sy001:
mov Ax,word ptr[si-3]
mov Cx,TSYMSIZE
div Cx
mov Bx,Dx ;index into hash table
shl Bx,1
shl Bx,1
mov Ax,SEG tsym
mov Es,Ax
les di,dword ptr es:[Bx].tsym
mov Ax,es
or Ax,Ax ;if segment 0
jne sy002
jmp sy991
sy002:
mov Ax,word ptr[si-3]
mov Dx,si
xor Cx,Cx
jmp short syLook
alignCode
syNext:
les di,es:[di] ; next symbol
mov Bx,es
or Bx,Bx ; continue if segment not 0
jnz sylook
jmp sy99
syLook:
mov bx,es:[di].12 ; pointer to name
cmp Ax,es:[Bx] ; check hash values
jne syNext
xchg Bx,di
mov cl,[si-1] ; lenght to cl
inc Cx
inc di
inc di ; skip hash
repz cmpsb ; check actual strings
mov di,Bx ; restore pointers
mov si,Dx
jnz syNext
syFound:
cmp byte ptr es:[bx].1bH,12 ; if (p->symkind == CLABEL)
jne @F
@@:
mov cx,iProcCur
jcxz noNest
push ax
cmp byte ptr es:[bx].1bH,2 ; if (p->symkind == CLABEL)
jne sy1
mov Ax,word ptr es:[bx].22h ; if (p->iProc)
sy01:
or ax,ax
jz noNest0
cmp cx,Ax ; if (p->iProc != iProcCur)
je noNest0
pop ax
xor cx,cx
jmp syNext
sy1:
cmp byte ptr es:[bx].1bH,6 ; if (p->symkind == EQU)
jne noNest0
mov Ax,word ptr es:[bx].1eh ; AX = p->csassume
jmp sy01
noNest0:
pop ax
noNest:
mov word ptr symptr,Bx
mov word ptr symptr+2,es
mov Ax,1
cmp crefing,al
je syCref
hRet ;Return true
syCref:
push Ax ;call crefing routines
call crefnew
call crefout
mov al,1
jmp short sy991
sy99:
xor Ax,Ax
sy991:
hRet
hEndp
endif ;M8086OPT
ifdef M8086OPT
;int PASCAL iskey (table)
hProc <iskey near>, <uses si di>, table:dword
hLocal l1:word, l2:word
cld
mov si,naim
cmp caseflag,1 ;if (caseflag == CASEL) {
jne noComputeHash
xor Dx,Dx ;nhash = 0;
;|*** for (uc = mapstr, lc = str; *lc; )
push ds
pop es
mov di,OFFSET mapstr
xor bh,bh
mov ah,bh
alignCode
$F791:
lodsb
or al,al
jz $L2001
mov bl,al
mov al,BYTE PTR _asmcupper_[bx]
stosb
add Dx,Ax
jmp short $F791
$L2001:
;|*** *uc = 0;
stosb ;0 terminate string
;|*** uc = mapstr;
mov si,OFFSET mapstr
mov Cx,di
sub Cx,si ;cb of string into Cx
mov Ax,Dx ;hash to Ax
jmp SHORT storeNhash ;Ax has computed hash
noComputeHash:
xor cx,cx
mov cl,[si-1]
inc Cx ;include NULL
mov ax,[si-3]
storeNhash:
mov l1,ax ;nhash
mov l2,Cx ;cb
;|*** for (p = table->kttable[nhash % table->ktsize]; p; p = p->knext)
les bx,table
mov di,es:[bx] ;es now contains symbol table segment
cwd
idiv WORD PTR es:[bx+2]
shl dx,1
add di,dx
mov Bx,si ;save uc name
alignCode
isLook:
cmp word ptr es:[di],0
je isNotFound
mov di,es:[di]
;|*** if ((nhash == p->khash) && (!strcmp (p->kname,uc)))
mov Ax,l1 ;nhash
cmp es:[di+4],Ax
jne isLook
; do an inline string compare
mov Dx,di ; save p
mov Cx,l2 ;cB
mov di,WORD PTR es:[di+2] ;Es:di = p->kname
repe cmpsb ; compare while equal
jcxz isFound
mov di,Dx ;restore registers
mov si,Bx
jmp isLook
;|*** return (p->ktoken);
isFound:
mov di,Dx
mov Ax,es:[di+6]
jmp SHORT isReturn
isNotFound:
alignCode
mov ax,-1
isReturn:
hRet
hEndp
endif ;M8086OPT
ifdef M8086OPT
hProc <skipblanks near>
mov bx,lbufp
dec bx
alignCode
ik1: ; skip leading white space
inc bx
mov al,[Bx]
cmp al,' '
je ik1
cmp al,9
je ik1
mov lbufp,bx
hRet
hEndp
endif
MC struc ;structure for macro call, see asm86.h for full comments
pTSHead dd ?
pTSCur dd ?
flags db ?
iLocal db ?
cbParms dw ?
locBase dw ?
countMC dw ?
pParmNames dw ?
pParmAct dw ?
svcondlevel db ?
svlastcond db ?
svelseflag db ?
db ?
rgPV dw ?
MC ends
ifdef M8086OPT
leOverflow2:
pop ax
leOverflow:
push ss
pop ds
xor Ax,Ax
stosb ; terminate line
mov ax, 100 ; E_LTL
push AX ; print error message
call ERRORC
jmp leFin2
; fast version to expand macro bodies / coded in C in asmirp.c
hProc <lineExpand near>, <uses si di>, pMC:word, pMacroLine:dword
assume es:@data
ifdef BCBOPT
mov fNoCompact, 0
endif
mov cbLeft, 511 ; LBUFMAX (asm86.h) - 4
les si,pMacroLine ; get pointer to macro prototype
mov bx,pMC
mov dl,[bx].iLocal ; dl: local base index
mov dh,080H ; dh: local base with high bit set
add dh,dl
lea bp,[bx].rgPV ; bp: pointer to actual arg array
mov di,offset lbuf ; si: pointer to new line
push ds
mov Ax,Es
mov ds,Ax ; set seg regs for ds:si & es:di
pop es
xor ah,ah
xor ch,ch ; set loop invariate
le1:
lodsb ; fetch next prefix
test al,080H ; check for parm
jnz leParmFound
mov cl,al
jcxz leFinished
sub es:[cbLeft],ax
jc leOverflow
repz movsb ; move non parameter entry
jmp le1
leParmFound: ; argment found
mov bl,al ; compute index
shl bx,1
shl bx,1
and bx,01FFH ; remove shifted high bit
add Bx,Bp
push ds
push es
pop ds ; save current ds and set to near
cmp al,dh ; determine parm type
jae leLocalFound
mov Bx,word ptr[Bx] ; fetch pointer to actual
xchg Bx,si ; save pMacroLine
lodsb
mov cl,al
jcxz leNullArg
sub cbLeft,ax
jnc le2
jmp leOverflow2
le2:
repz movsb ; move parameter entry
leNullArg:
mov si,Bx ; restore saved pMacroLine
pop ds
xor ah, ah
jmp le1
leLocalFound:
cmp word ptr[Bx],0 ; check to see if the local
jz leBuildLocal ; is defined
leLocalMove:
xchg Bx,si ; save pMacroLine
sub cbLeft,6
jnc le3
jmp leOverflow2
le3:
mov Ax,'??' ; store leading ??
stosw
movsw ; and then remaining xxxx
movsw
jmp leNullArg
leBuildLocal:
push Dx ; call runtime helper to generate name
push Bx
push Es
xor ah,ah
sub al,dh
mov Bx,Sp ; fetch pMC
mov Bx,[Bx+8+4+4]
add Ax,[Bx].locBase
xor Bx,BX
push Bx ; offsetAscii((long) .. )
push Ax
call offsetAscii
pop Es
pop Bx
pop Dx
mov Ax,objectascii ; copy 4 byte local name to cach
mov [Bx],AX
mov Ax,objectascii+2
mov [Bx].2,AX
jmp leLocalMove
leFinished:
mov ax,es ; restore ds
mov ds,ax
leFin2:
mov linebp,di ; set linebp
mov si,offset lbuf
mov lbufp,si ; lbufp= lbuf
sub di,si
mov cx, di
mov linelength, al ; linelength = linbp - lbuf
cmp fNeedList,0 ;for listing copy to list buffer
je @F
mov di,offset linebuffer
shr cx,1
rep movsw
rcl cx,1
rep movsb
@@:
.8086
hRet
ifndef MSDOS
.286
endif
hEndp
endif ;M8086OPT
ifdef M8086OPT
;*** expandTM - expand text macro in naim in lbuf/lbufp
;*
;* expandTM (equtext);
;*
;* Entry equtext = replacement string
;* naim = text macro
;* begatom = first character in lbuf to replace
;* endatom = first character in lbuf after string to replace
;* Exit lbuf = new line to be parsed
;* Returns
;* Calls
;* Note Shifts characters from lbufp to make substitution of TM.
;* Inserts replacement string at begatom
;*/
hProc <expandTM near>, <uses si di>, equtext:word
hLocal cbEndatom:word, cbNaim:word, cbText:word, fShifted:byte
cld ; String instructions go forward
mov ax, ds ; Set es to @data
mov es, ax ;
xor ax, ax ; Will stop scanning when [di] == [al] == 0
mov fshifted, 0 ; Haven't shifted line yet
mov cx, linebp ; Calculate cbEndatom == strlen(endatom)
sub cx, endatom ; but use (linebp - endatom + 1) as method
inc cx ;
mov cbEndatom, cx ; Store result in cbEndatom
mov cx, endatom ; Calculate cbNaim == strlen(naim)
sub cx, begatom ; but use (endatom - begatom) as method
mov cbNaim, cx ; Store result in cbNaim
mov di, equtext ; Calculate cbText == strlen(equtext)
mov cx, -1 ;
repne scasb ;
not cx ; [cx] == length of equtext
dec cx ; don't count NULL
mov cbText, cx ; Store result in cbText
cmp cbNaim, cx ; Q: Is replacement longer than name?
jl shiftline ; Y: Must shift endatom string to the right
copytext:
mov di, begatom ; Copy replacement text into lbuf
mov si, equtext ;
mov cx, cbText ; Number of bytes to copy
shr cx, 1 ;
rep movsw ;
jnc etm2 ;
movsb ;
etm2:
cmp fShifted, 0 ; Q: Have already shifted line right?
jne etmEnd ; Y: Done
mov si, endatom ; Q: Is cbNaim == cbText?
cmp di, si ;
je etmEnd ; Y: Done
mov cx, cbEndatom ; N: Must shift endatom string left
shr cx, 1 ;
rep movsw ;
jnc etm3 ;
movsb ;
etm3:
mov linebp, di ;
jmp etmEnd ; Done
shiftline: ; Shift string at endatom to right
mov cx, cbEndatom ; Number of bytes to move
mov si, linebp ; [si] = end of string in lbuf
mov di, si ;
add di, cbText ;
sub di, cbNaim ; di == si + amount to shift string right
mov linebp, di ;
mov dx, di ; check if line too long
sub dx, OFFSET lbuf ;
cmp dx, 512 ; LBUFMAX (asm86.h)
jge eltl ; line too long
std ; String instructions go backwards
rep movsb ; Shift line
inc fShifted ;
cld ; String instructions go forward again
jmp copytext ;
eltl:
mov ax,100 ; Error E_LTL Line too long
push ax ;
call ERRORC ;
mov di, begatom
mov byte ptr [di], 0 ; Truncate line
etmEnd:
mov ax, begatom ; Reset lbufp to point to start of next
mov lbufp, ax ; token
hRet
hEndp
endif ;M8086OPT
ifdef MSDOS
ifdef M8086OPT
;*** farwrite - write with far buffer
; farwrite(ofh,buf,count);
hProc <farwrite far>, handle:word, buffer:dword, count:word
mov ax,handle
mov cx,count
push ds
lds dx,buffer
mov bh,40h ; write
xchg ax,bx
ifdef CPDOS
push bx ; file handle
push ds ; buffer (selector)
push dx ; buffer (offset)
push cx ; # bytes to read
mov ax,@data
push ax ; reply area (selector)
mov ax,offset rarea
push ax ; reply area (offset)
call DosWrite
else
int 21h
endif
pop ds
ifdef CPDOS
or ax,ax
mov ax, word ptr rarea
jnz fwriterr
else
jc fwriterr
endif
cmp ax,count
je fwriteok
fwriterr:
mov objerr,-1
fwriteok:
hRet
hEndp
endif ;M8086OPT
endif
;*** farAvail ()
ifdef MSDOS
ifndef CPDOS
hProc <farAvail far>
or Bx,0FFFFH ;request max memory from dos
mov ah,48H ;paragraphs left in Bx
int 21H
mov ah,48H ;then allocate it
int 21H
jnc noMem
xor Bx,Bx
noMem:
mov Ax,16
cwd
mul Bx ;return paragraphs * 16
hRet
hEndp
endif
endif
end
