1239 lines
20 KiB
NASM
1239 lines
20 KiB
NASM
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
|