707 lines
22 KiB
NASM
707 lines
22 KiB
NASM
|
; =====> SBIGMATH.ASM
|
|||
|
|
;***************************************
|
|||
|
|
;* TIPC Scheme '84 Runtime Support *
|
|||
|
|
;* Bignum Math Utilities *
|
|||
|
|
;* *
|
|||
|
|
;* (C) Copyright 1984,1985 by Texas *
|
|||
|
|
;* Instruments Incorporated. *
|
|||
|
|
;* All rights reserved. *
|
|||
|
|
;* *
|
|||
|
|
;* Date Written: June 1984 *
|
|||
|
|
;* Last Modification: 27 May 1986 *
|
|||
|
|
;***************************************
|
|||
|
|
include scheme.equ
|
|||
|
|
|
|||
|
|
DGROUP group data
|
|||
|
|
data segment word public 'DATA'
|
|||
|
|
assume DS:DGROUP
|
|||
|
|
data ends
|
|||
|
|
|
|||
|
|
XGROUP GROUP PROGX
|
|||
|
|
PROGX segment byte public 'PROGX'
|
|||
|
|
assume CS:XGROUP,DS:DGROUP
|
|||
|
|
|
|||
|
|
; Convert a bignum to a flonum
|
|||
|
|
; Calling sequence: big2flo(bigptr,floptr)
|
|||
|
|
; Where: bigptr ---- pointer to bignum workspace
|
|||
|
|
; floptr ---- pointer to flonum
|
|||
|
|
b2fargs struc
|
|||
|
|
dw ? ;Caller's BP
|
|||
|
|
dd ? ;Return address
|
|||
|
|
dw ? ;Another return address
|
|||
|
|
big dw ? ;Pointer to bignum
|
|||
|
|
flo dw ? ;Pointer to flonum
|
|||
|
|
b2fargs ends
|
|||
|
|
|
|||
|
|
%big2flo proc far
|
|||
|
|
push BP
|
|||
|
|
mov BP,SP
|
|||
|
|
cld ;Direction forward
|
|||
|
|
mov SI,[BP].big ;Point DS:SI to working bignum
|
|||
|
|
mov CX,[SI] ;Get size
|
|||
|
|
cmp CX,3
|
|||
|
|
ja all64 ;Jump if at least 64 bits
|
|||
|
|
add SI,3 ;Point to bignum proper
|
|||
|
|
xor BX,BX
|
|||
|
|
xor DI,DI
|
|||
|
|
lodsw ;Fetch least sig. word
|
|||
|
|
mov DX,AX ;Store in DX
|
|||
|
|
dec CX
|
|||
|
|
jcxz smljust ;Jump if no more bignum words
|
|||
|
|
lodsw ;Else get next least sig. word
|
|||
|
|
mov DI,AX
|
|||
|
|
dec CX
|
|||
|
|
jcxz smljust ;Jump if no more bignum words
|
|||
|
|
lodsw ;Get 3rd least sig. word
|
|||
|
|
mov BX,AX
|
|||
|
|
smljust: xor AX,AX ;Clear most sig. word
|
|||
|
|
jmp short justify ;Left-justify the number
|
|||
|
|
all64: shl CX,1 ;Point SI to 4th most sig. word
|
|||
|
|
add SI,CX
|
|||
|
|
sub SI,5
|
|||
|
|
lodsw ;Load bignum into registers
|
|||
|
|
mov DX,AX
|
|||
|
|
lodsw
|
|||
|
|
mov DI,AX
|
|||
|
|
lodsw
|
|||
|
|
mov BX,AX
|
|||
|
|
lodsw
|
|||
|
|
;JUSTIFY: At this stage, the 64 most significant bignum bits are in
|
|||
|
|
; AX:BX:DI:DX respectively, AX most significant
|
|||
|
|
justify: mov SI,[BP].big ;Fetch pointer to bignum again
|
|||
|
|
mov CX,[SI] ;Get size (words)
|
|||
|
|
cmp CX,40h
|
|||
|
|
ja toobig ;Jump if bignum too big
|
|||
|
|
cmp CX,4 ;Skip if not a small bignum
|
|||
|
|
jae enough
|
|||
|
|
mov CX,4 ;Otherwise, start with constant
|
|||
|
|
enough: shl CX,1 ;Multiply by 16 (size in bits)
|
|||
|
|
shl CX,1
|
|||
|
|
shl CX,1
|
|||
|
|
shl CX,1
|
|||
|
|
justflp: dec CX ;Reduce exponent
|
|||
|
|
shl DX,1 ;Shift bignum left
|
|||
|
|
rcl DI,1
|
|||
|
|
rcl BX,1
|
|||
|
|
rcl AX,1
|
|||
|
|
jnc justflp ;Until most significant 1 vanishes
|
|||
|
|
add CX,3ffh ;Add flonum exponent constant
|
|||
|
|
mov SI,DI ;Now use SI for num, DI for address
|
|||
|
|
shftrt: shr CX,1 ;Shift CX:AX:BX:SI:DX as one
|
|||
|
|
rcr AX,1
|
|||
|
|
rcr BX,1
|
|||
|
|
rcr SI,1
|
|||
|
|
rcr DX,1
|
|||
|
|
cmp CX,80h ;Until most sig. exponent bit is in 2nd
|
|||
|
|
jae shftrt ; most sig. bit of CL
|
|||
|
|
mov DI,[BP].big ;Get pointer to bignum again
|
|||
|
|
test byte ptr[DI]+2,1 ;Negative?
|
|||
|
|
jz posskip ;No, skip
|
|||
|
|
or CL,80h ;Set sign bit
|
|||
|
|
posskip: mov DI,[BP].flo ;Point ES:DI to flonum
|
|||
|
|
push AX ;Save part of new flonum
|
|||
|
|
mov AL,DH ;Write to flonum space
|
|||
|
|
stosb
|
|||
|
|
mov AX,SI
|
|||
|
|
stosw
|
|||
|
|
mov AX,BX
|
|||
|
|
stosw
|
|||
|
|
pop AX
|
|||
|
|
stosw
|
|||
|
|
mov AL,CL
|
|||
|
|
stosb
|
|||
|
|
xor AX,AX ;Return 0 if all well
|
|||
|
|
pop BP ;Restore BP
|
|||
|
|
ret
|
|||
|
|
toobig: mov AX,1 ;Return 1 if conversion impossible
|
|||
|
|
pop BP
|
|||
|
|
ret
|
|||
|
|
%big2flo endp
|
|||
|
|
|
|||
|
|
; Convert fixnum to bignum
|
|||
|
|
; Calling sequence: fix2big(fixnum,bigptr)
|
|||
|
|
; Where: fixnum ---- Integer of small absolute value
|
|||
|
|
; bigptr ---- Pointer to bignum space
|
|||
|
|
f2bargs struc
|
|||
|
|
dw ? ;Caller's BP
|
|||
|
|
dd ? ;Return address
|
|||
|
|
dw ? ;Another return address
|
|||
|
|
fix dw ? ;Fixnum
|
|||
|
|
bigp dw ? ;Pointer to bignum
|
|||
|
|
f2bargs ends
|
|||
|
|
|
|||
|
|
%fix2big proc far
|
|||
|
|
push BP
|
|||
|
|
mov BP,SP
|
|||
|
|
mov DI,[BP].bigp ;Point ES:DI to bignum
|
|||
|
|
mov AX,1 ;Fill size field
|
|||
|
|
stosw
|
|||
|
|
xor AL,AL ;Clear AL
|
|||
|
|
mov BX,[BP].fix ;Fetch fixnum value
|
|||
|
|
shl BX,1 ;Put sign bit in AL
|
|||
|
|
rcl AL,1
|
|||
|
|
stosb ;Fill sign field
|
|||
|
|
sar BX,1 ;Restore fixnum
|
|||
|
|
or AL,AL ;Negative fixnum?
|
|||
|
|
jz posfx ;Skip if positive
|
|||
|
|
neg BX ;Otherwise, find absolute value
|
|||
|
|
posfx: mov [DI],BX ;Store magnitude of fixnum
|
|||
|
|
pop BP ;Restore BP
|
|||
|
|
ret
|
|||
|
|
%fix2big endp
|
|||
|
|
|
|||
|
|
;;;; Decrement bignum
|
|||
|
|
;;;; Calling sequence: sub1big(buf)
|
|||
|
|
;;;; Where: buf ---- pointer to bignum
|
|||
|
|
;;;unibig struc
|
|||
|
|
;;; dw ? ;Return address
|
|||
|
|
;;;bbuf dw ? ;Pointer to working bignum
|
|||
|
|
;;;unibig ends
|
|||
|
|
;;; public sub1big
|
|||
|
|
;;;sub1big proc far
|
|||
|
|
;;; mov BX,SP ;Get bignum pointer
|
|||
|
|
;;; mov SI,SS:[BX].bbuf
|
|||
|
|
;;; test byte ptr[SI]+2,1 ;Is bignum negative?
|
|||
|
|
;;; jnz incbig ;If so, increase magnitude
|
|||
|
|
;;; jmp short decbig ;Else decrease magnitude
|
|||
|
|
;;;sub1big endp
|
|||
|
|
|
|||
|
|
;;;; Increment bignum
|
|||
|
|
;;;; Calling sequence: add1big(buf)
|
|||
|
|
;;; public add1big
|
|||
|
|
;;;add1big proc far
|
|||
|
|
;;; mov BX,SP ;Get bignum pointer
|
|||
|
|
;;; mov SI,SS:[BX].bbuf
|
|||
|
|
;;; test byte ptr[SI]+2,1 ;Is bignum negative?
|
|||
|
|
;;; jnz decbig ;Yes, decrease magnitude
|
|||
|
|
;;;;INCBIG increments magnitude of working bignum at DS:SI
|
|||
|
|
;;;incbig: mov DI,SI ;Save bignum pointer
|
|||
|
|
;;; mov CX,[SI] ;Get length (words)
|
|||
|
|
;;; add SI,3 ;Point to bignum proper
|
|||
|
|
;;;carrylp: inc word ptr[SI] ;Increment bignum
|
|||
|
|
;;; jnz done ;If no carry, finished
|
|||
|
|
;;; inc SI ;Else go to next word
|
|||
|
|
;;; inc SI
|
|||
|
|
;;; loop carrylp ;Loop while not end of bignum
|
|||
|
|
;;; mov word ptr[SI],1 ;Else place final 1
|
|||
|
|
;;; inc word ptr[DI] ;Lengthen bignum
|
|||
|
|
;;;done: ret
|
|||
|
|
;;;;DECBIG decrements magnitude of working bignum at DS:SI
|
|||
|
|
;;;decbig: mov DI,SI ;Save pointer
|
|||
|
|
;;; mov CX,[SI] ;Get length
|
|||
|
|
;;; add SI,3 ;Point to bignum proper
|
|||
|
|
;;; dec CX ;CX = (length - 1)
|
|||
|
|
;;;borrowlp: lodsw ;Load current word
|
|||
|
|
;;; sub AX,1 ;Decrement and store
|
|||
|
|
;;; mov [SI-2],AX
|
|||
|
|
;;; jnc done ;Jump if no borrow
|
|||
|
|
;;; loop borrowlp ;Loop if not on last word
|
|||
|
|
;;; dec word ptr[SI] ;Else decrement last word
|
|||
|
|
;;; jnz done ;Jump if bignum not to be shortened
|
|||
|
|
;;; dec word ptr[DI] ;Else shorten
|
|||
|
|
;;; ret
|
|||
|
|
;;;add1big endp
|
|||
|
|
|
|||
|
|
; set up big1's index for comparison, used with %magcomp
|
|||
|
|
%pbig1 proc near
|
|||
|
|
shl CX,1
|
|||
|
|
dec SI
|
|||
|
|
add SI,CX
|
|||
|
|
shr CX,1
|
|||
|
|
ret
|
|||
|
|
%pbig1 endp
|
|||
|
|
|
|||
|
|
; set up big1's index for comparison, used with %magcomp
|
|||
|
|
%pbig2 proc near
|
|||
|
|
shl CX,1
|
|||
|
|
dec DI
|
|||
|
|
add DI,CX
|
|||
|
|
shr CX,1
|
|||
|
|
ret
|
|||
|
|
%pbig2 endp
|
|||
|
|
|
|||
|
|
; Compare magnitudes of two bignums
|
|||
|
|
; Calling sequence: data = magcomp(big1,big2)
|
|||
|
|
; Where: big1,big2 -- pointers to bignum buffers
|
|||
|
|
; data ------- a positive integer as follows:
|
|||
|
|
; Bit 0 set iff |BIG1| < |BIG2|
|
|||
|
|
; Bit 1 set iff |BIG1| > |BIG2|
|
|||
|
|
; Bit 2 set iff BIG1 < BIG2
|
|||
|
|
; Bit 3 set iff BIG1 > BIG2
|
|||
|
|
; Bit 4 set iff BIG1,BIG2 have same sign
|
|||
|
|
twobigs struc
|
|||
|
|
dd ? ;Return address
|
|||
|
|
dw ? ;Another return address
|
|||
|
|
big1 dw ? ;First bignum
|
|||
|
|
big2 dw ? ;Second bignum
|
|||
|
|
twobigs ends
|
|||
|
|
|
|||
|
|
%magcomp proc far
|
|||
|
|
xor AL,AL ;Clear AL
|
|||
|
|
xor DX,DX ; clear DX
|
|||
|
|
mov BX,SP ;Fetch bignum pointers
|
|||
|
|
mov SI,[BX].big1
|
|||
|
|
mov DI,[BX].big2
|
|||
|
|
mov AH,[SI]+2 ;Get sign bits
|
|||
|
|
mov DH,[DI]+2
|
|||
|
|
xor DH,AH ;Put XOR of signs into carry
|
|||
|
|
shr DH,1
|
|||
|
|
jc sgnskp ;Jump if different signs
|
|||
|
|
or AL,16 ;Else set proper bit in AL
|
|||
|
|
sgnskp: rcl AH,1
|
|||
|
|
mov CX,[SI] ;Get BIG1's length
|
|||
|
|
mov DX,[DI] ; get BIG2's length
|
|||
|
|
cld ;Direction forward
|
|||
|
|
cmpsw ;Compare lengths
|
|||
|
|
jb bigr2 ;Jump if BIG2 longer
|
|||
|
|
ja bigr1 ;Jump if BIG1 longer
|
|||
|
|
same_ln: call %pbig1 ;If same size, point SI,DI to last words
|
|||
|
|
call %pbig2 ; (most significant)
|
|||
|
|
std ;Direction backward
|
|||
|
|
repe cmpsw ;Repeat until unequal
|
|||
|
|
jb rbig2
|
|||
|
|
ja rbig1
|
|||
|
|
test AH,1 ;Signs same?
|
|||
|
|
jz compend ;Yes, exit
|
|||
|
|
difsign: test AH,2 ;Is BIG1 positive?
|
|||
|
|
jnz grtr2 ;No, BIG2 is greater
|
|||
|
|
jz grtr1 ;Else BIG1 is greater
|
|||
|
|
bigr1: call %pbig1
|
|||
|
|
cmp word ptr [SI],0 ; check high word,
|
|||
|
|
jne rbig1 ; big1 is really bigger
|
|||
|
|
mov SI,[BX].big1 ; restore SI
|
|||
|
|
inc SI
|
|||
|
|
inc SI
|
|||
|
|
dec CX ; high order word is empty
|
|||
|
|
cmp CX,DX ; compare length's again
|
|||
|
|
je same_ln ; same length
|
|||
|
|
jmp bigr1 ; repeat until unequal or same lengths
|
|||
|
|
|
|||
|
|
rbig1: or AL,2 ;Set the |BIG1|>|BIG2| bit
|
|||
|
|
test AH,1 ;Signs same?
|
|||
|
|
jnz difsign ;No, different signs
|
|||
|
|
test AH,2 ;Both positive?
|
|||
|
|
jnz grtr2 ;No, so BIG2 is greater
|
|||
|
|
grtr1: or AL,8 ;Set the BIG1>BIG2 bit
|
|||
|
|
cld ; Set direction forward (JCJ-12/6/84)
|
|||
|
|
ret
|
|||
|
|
bigr2: push CX
|
|||
|
|
mov CX,DX ; swap CX and DX
|
|||
|
|
pop DX
|
|||
|
|
call %pbig2 ; Set up big2's pointers
|
|||
|
|
cmp word ptr [DI],0 ; check high word
|
|||
|
|
jne rbig2 ; big2 really is bigger
|
|||
|
|
mov DI,[BX].big2 ; restore DI
|
|||
|
|
inc DI
|
|||
|
|
inc DI
|
|||
|
|
dec CX ; high order word is empty
|
|||
|
|
cmp DX,CX ; compare length's again
|
|||
|
|
je same_ln ;
|
|||
|
|
jmp bigr2 ; repeat until unequal or same lengths
|
|||
|
|
|
|||
|
|
rbig2: or AL,1 ;Set the |BIG1|<|BIG2| bit
|
|||
|
|
test AH,1 ;Signs same?
|
|||
|
|
jnz difsign ;No, different signs
|
|||
|
|
test AH,2 ;Both positive?
|
|||
|
|
jnz grtr1 ;No, BIG1 is greater
|
|||
|
|
grtr2: or AL,4 ;Set the BIG1<BIG2 bit
|
|||
|
|
compend: cld ; Set direction forward (JCJ-12/6/84)
|
|||
|
|
ret
|
|||
|
|
%magcomp endp
|
|||
|
|
|
|||
|
|
; Add magnitudes of bignums
|
|||
|
|
; Calling sequence: bigadd(big1,big2)
|
|||
|
|
; Where: big1 ---- bignum of lesser magnitude
|
|||
|
|
; big2 ---- bignum of greater magnitude
|
|||
|
|
; When done, BIG2 will hold the sum
|
|||
|
|
|
|||
|
|
%bigadd proc far
|
|||
|
|
mov BX,SP ;Fetch bignum pointers
|
|||
|
|
mov SI,[BX].big1
|
|||
|
|
mov DI,[BX].big2
|
|||
|
|
cld ;Direction forward
|
|||
|
|
lodsw ;Get length of smaller bignum
|
|||
|
|
mov CX,AX ;Save length
|
|||
|
|
sub AX,[DI] ;Find and push difference in lengths
|
|||
|
|
neg AX
|
|||
|
|
push AX
|
|||
|
|
inc SI ;Point SI,DI to bignums proper
|
|||
|
|
add DI,3
|
|||
|
|
clc ;Prepare to add
|
|||
|
|
addlp: lodsw ;Fetch source addend
|
|||
|
|
adc [DI],AX ;Add to destination addend
|
|||
|
|
inc DI ;Point DI to next word
|
|||
|
|
inc DI
|
|||
|
|
loop addlp ;Do until smaller bignum exhausted
|
|||
|
|
pop CX ;Fetch length difference (CF unchanged)
|
|||
|
|
jnc doneadd ;Stop if no carry
|
|||
|
|
mov SI,[BX].big2 ;Point SI to destination bignum
|
|||
|
|
jcxz samlen ;Jump if bignums the same length
|
|||
|
|
adclp: inc word ptr[DI] ;Otherwise, add carry
|
|||
|
|
jnz doneadd ;Jump if no resultant carry
|
|||
|
|
add DI,2 ;Point DI to next word
|
|||
|
|
loop adclp ;Do until whole number is done or no carry
|
|||
|
|
samlen: mov word ptr[DI],1 ;Store last carry
|
|||
|
|
inc word ptr[SI] ;Note bignum's size increase
|
|||
|
|
doneadd: ret
|
|||
|
|
%bigadd endp
|
|||
|
|
|
|||
|
|
; Subtract magnitudes of bignums
|
|||
|
|
; Calling sequence: bigsub(big1,big2)
|
|||
|
|
; Where: big1 ---- bignum of lesser magnitude
|
|||
|
|
; big2 ---- bignum of greater magnitude
|
|||
|
|
; When done, BIG2 will hold the difference
|
|||
|
|
; When done, BIG2 will hold the sum
|
|||
|
|
|
|||
|
|
%bigsub proc far
|
|||
|
|
mov BX,SP ;Fetch pointers to bignums
|
|||
|
|
mov SI,[BX].big1
|
|||
|
|
mov DI,[BX].big2
|
|||
|
|
cld ;Direction forward
|
|||
|
|
lodsw ;Get length of smaller bignum
|
|||
|
|
mov CX,AX
|
|||
|
|
inc SI ;Point SI,DI to bignums proper
|
|||
|
|
add DI,3
|
|||
|
|
clc ;Prepare to subtract
|
|||
|
|
sublp: lodsw ;Fetch subtrahend
|
|||
|
|
sbb [DI],AX ;Subtract
|
|||
|
|
inc DI ;Point DI to next word
|
|||
|
|
inc DI
|
|||
|
|
loop sublp ;Do until smaller bignum exhausted
|
|||
|
|
jnc pack ;Jump if no borrow
|
|||
|
|
borlp: mov AX,[DI] ;Fetch word
|
|||
|
|
sub AX,1 ;Decrement and store
|
|||
|
|
stosw
|
|||
|
|
jc borlp ;Jump if further borrowing needed
|
|||
|
|
pack: mov DI,[BX].big2 ;Fetch pointer to 2nd bignum
|
|||
|
|
mov SI,DI ;Save pointer in SI
|
|||
|
|
mov AX,[SI] ;Fetch bignum length
|
|||
|
|
mov CX,AX ;Save (length-1) in CX
|
|||
|
|
dec CX
|
|||
|
|
shl AX,1 ;Point DI to last word of bignum
|
|||
|
|
inc AX
|
|||
|
|
add DI,AX
|
|||
|
|
std ;Direction backward
|
|||
|
|
xor AX,AX ;Find number of leading 0-words
|
|||
|
|
repe scasw ; (not counting least sig. word)
|
|||
|
|
jz smlskp ;Jump if only one non-0 word
|
|||
|
|
inc CX ;Else, at least 2 non-0 words
|
|||
|
|
smlskp: inc CX ;Form (length - # of leading 0-words)
|
|||
|
|
mov [SI],CX ;Save in bignum size field
|
|||
|
|
cld ;Clear the direction flag
|
|||
|
|
ret
|
|||
|
|
%bigsub endp
|
|||
|
|
|
|||
|
|
; Multiply two bignums
|
|||
|
|
; Calling sequence: bigmul(big1,big2,big3)
|
|||
|
|
; Where: big1,big2 -- factors
|
|||
|
|
; big3 ------- destination of product
|
|||
|
|
mulargs struc
|
|||
|
|
carry dw ? ;Multiplication carry
|
|||
|
|
dw ? ;Caller's BP
|
|||
|
|
dd ? ;Return address
|
|||
|
|
dw ? ;Another return address
|
|||
|
|
mbig1 dw ? ;Factor of greater magnitude
|
|||
|
|
mbig2 dw ? ;Factor of lesser magnitude
|
|||
|
|
mbig3 dw ? ;Product destination
|
|||
|
|
mulargs ends
|
|||
|
|
; When done, BIG2 will hold the sum
|
|||
|
|
|
|||
|
|
%bigmul proc far
|
|||
|
|
push BP ;Save BP
|
|||
|
|
dec SP ;Create space for multiplication carry
|
|||
|
|
dec SP
|
|||
|
|
mov BP,SP ;Point BP to args
|
|||
|
|
cld ;Direction forward
|
|||
|
|
mov SI,[BP].mbig1 ;Fetch factor pointers
|
|||
|
|
mov DI,[BP].mbig2
|
|||
|
|
lodsw ;Fetch BIG1's length
|
|||
|
|
mov CX,AX ;Put sum of lengths in CX
|
|||
|
|
add CX,[DI]
|
|||
|
|
scasw ;Which has greater magnitude?
|
|||
|
|
jae xchgskp ;Jump if BIG1 is not smaller
|
|||
|
|
xchg DI,SI
|
|||
|
|
xchgskp: lodsb ;Fetch one factor's sign
|
|||
|
|
xor AL,[DI] ;XOR with the other factor's sign
|
|||
|
|
inc DI ;Point DI to bignum proper
|
|||
|
|
mov BX,DI ;And store in BX
|
|||
|
|
mov DI,[BP].mbig3 ;Store length into product
|
|||
|
|
xchg AX,CX
|
|||
|
|
stosw
|
|||
|
|
push AX ;Save total length of product
|
|||
|
|
xchg AX,CX ;Store sign byte into product
|
|||
|
|
stosb
|
|||
|
|
push DI ;Set product to 0 over whole length
|
|||
|
|
xor AX,AX
|
|||
|
|
rep stosw
|
|||
|
|
pop DI
|
|||
|
|
xchg DI,BX ;Restore BX and DI
|
|||
|
|
mov CX,[DI]-3 ;Fetch length of BIG2
|
|||
|
|
sub BX,SI ;Point [BX+SI-2] to product
|
|||
|
|
dec BX
|
|||
|
|
dec BX
|
|||
|
|
mov [BP].mbig1,SI ;Store pointer to data of BIG1
|
|||
|
|
mullp2: push CX ;Save counter of BIG2 words
|
|||
|
|
;Add (BIG1*part of BIG2) to current product
|
|||
|
|
mov word ptr[BP].carry,0 ;Clear carry in
|
|||
|
|
mov SI,[BP].mbig1 ;Fetch bignum pointer
|
|||
|
|
mov CX,[SI]-3 ;Get number of words in bignum
|
|||
|
|
mullp: lodsw ;Get factor part from BIG1
|
|||
|
|
mul word ptr[DI] ;Multiply by factor part from BIG2
|
|||
|
|
add AX,[BP].carry ;Add carry in
|
|||
|
|
adc DX,0
|
|||
|
|
add [BX+SI],AX ;Add product part into BIG3
|
|||
|
|
adc DX,0 ;Adjust and store carry
|
|||
|
|
mov [BP].carry,DX
|
|||
|
|
loop mullp ;Continue for all BIG1
|
|||
|
|
mov [BX+SI+2],DX ;Store carry remaining
|
|||
|
|
;
|
|||
|
|
pop CX ;Restore BIG2 counter
|
|||
|
|
inc DI ;Point DI to next word in BIG2
|
|||
|
|
inc DI
|
|||
|
|
inc BX ;Point BX to next word in BIG3
|
|||
|
|
inc BX
|
|||
|
|
loop mullp2 ;Continue for all BIG2
|
|||
|
|
mov BX,[BP].mbig3 ;Fetch pointer to BIG3 (beginning)
|
|||
|
|
pop SI ;Point SI to last word of product
|
|||
|
|
shl SI,1
|
|||
|
|
inc SI
|
|||
|
|
add SI,BX
|
|||
|
|
cmp word ptr[SI],0 ;Test last word for zero
|
|||
|
|
jnz muldone ;Done if not zero
|
|||
|
|
dec word ptr[BX] ;Decrement bignum length
|
|||
|
|
muldone: inc SP ;Discard temporary carry variable
|
|||
|
|
inc SP
|
|||
|
|
pop BP ;Restore BP
|
|||
|
|
ret
|
|||
|
|
%bigmul endp
|
|||
|
|
|
|||
|
|
; Divide one bignum by another
|
|||
|
|
; Calling sequence: bigdiv(dvdnd,dvsr,quot)
|
|||
|
|
; Where: dvdnd ----- dividend
|
|||
|
|
; dvsr ------ divisor
|
|||
|
|
; quot ------ quotient
|
|||
|
|
divargs struc
|
|||
|
|
dw ? ;Caller's BP
|
|||
|
|
dvsrsz dw ? ;Size of divisor (words)
|
|||
|
|
bitcount dw ? ;Estimated bits in quotient
|
|||
|
|
align dw ? ;Alignment of dividend to divisor
|
|||
|
|
ldvsr dw ? ;Pointer to last word of divisor
|
|||
|
|
dd ? ;Return address
|
|||
|
|
dw ? ;Another return address
|
|||
|
|
dvdnd dw ? ;Dividend
|
|||
|
|
dvsr dw ? ;Divisor
|
|||
|
|
quot dw ? ;Quotient
|
|||
|
|
divargs ends
|
|||
|
|
; When done, BIG2 will hold the sum
|
|||
|
|
|
|||
|
|
%bigdiv proc far
|
|||
|
|
sub SP,8 ;Room for local variables
|
|||
|
|
push BP
|
|||
|
|
mov BP,SP
|
|||
|
|
mov DI,[BP].quot ;Get pointers to arguments
|
|||
|
|
mov SI,[BP].dvdnd
|
|||
|
|
mov BX,[BP].dvsr
|
|||
|
|
cld ;Direction forward
|
|||
|
|
lodsw ;Get dividend length
|
|||
|
|
mov CX,[BX] ;Fetch divisor length
|
|||
|
|
cmp CX,1 ;Check divisor for 0
|
|||
|
|
jne dvsrok
|
|||
|
|
cmp word ptr[BX]+3,0 ;Check divisor data word
|
|||
|
|
jnz dvsrok
|
|||
|
|
mov AX,CX ;Put nonzero value in AX
|
|||
|
|
pop BP
|
|||
|
|
add SP,8 ;Restore stack
|
|||
|
|
ret ;Exit
|
|||
|
|
dvsrok: inc BX ;Point BX+1 to divisor sign
|
|||
|
|
mov DX,CX ;Find & store pointer to last divisor word
|
|||
|
|
shl DX,1
|
|||
|
|
add DX,BX
|
|||
|
|
mov [BP].ldvsr,DX
|
|||
|
|
sub AX,CX ;Find dividend-divisor length difference
|
|||
|
|
mov DX,AX ;Save in DX for now
|
|||
|
|
inc AX ;Store maximum quotient length (words)
|
|||
|
|
stosw
|
|||
|
|
inc CX ;Save length of working divisor
|
|||
|
|
mov [BP].dvsrsz,CX
|
|||
|
|
dec AX ;Find and store quotient bit count
|
|||
|
|
shl AX,1
|
|||
|
|
shl AX,1
|
|||
|
|
shl AX,1
|
|||
|
|
shl AX,1
|
|||
|
|
inc AX
|
|||
|
|
mov [BP].bitcount,AX
|
|||
|
|
lodsb ;Get dividend sign
|
|||
|
|
xor AL,[BX]+1 ;Find and store quotient sign
|
|||
|
|
stosb
|
|||
|
|
mov [BP].dvdnd,SI ;Save pointer to dividend proper
|
|||
|
|
mov [BP].quot,DI ;Save pointer to quotient proper
|
|||
|
|
xor AX,AX ;Zero first two words of quotient
|
|||
|
|
stosw
|
|||
|
|
std
|
|||
|
|
stosw
|
|||
|
|
dec DX ;Account for extra divisor word
|
|||
|
|
shl DX,1 ;Store divisor-dividend alignment
|
|||
|
|
add DX,SI
|
|||
|
|
mov [BP].align,DX
|
|||
|
|
mov word ptr[BX],0 ;Put 0-word at start of divisor
|
|||
|
|
mov [BP].dvsr,BX ;Save pointer to working divisor
|
|||
|
|
bigdivlp: call divcmp ;Dividend less than aligned divisor?
|
|||
|
|
jb divbit0 ;Yes, perform division
|
|||
|
|
test word ptr[BX],8000h ;Can divisor be shifted left?
|
|||
|
|
jnz divbit1 ;No, perform division
|
|||
|
|
mov SI,[BP].dvsr ;Otherwise, shift entire divisor left
|
|||
|
|
mov CX,[BP].dvsrsz
|
|||
|
|
clc ;Start by shifting in 0
|
|||
|
|
shllp: rcl word ptr[SI],1 ;Shift through divisor word
|
|||
|
|
inc SI ;Point SI to next word
|
|||
|
|
inc SI
|
|||
|
|
loop shllp ;Do for entire divisor
|
|||
|
|
inc [BP].bitcount ;Increase bit count
|
|||
|
|
jmp bigdivlp ;See if divisor is big enough yet
|
|||
|
|
divlp: call divcmp ;Dividend less than aligned divisor?
|
|||
|
|
cld ; (Direction forward)
|
|||
|
|
jb divbit0 ;Yes, rotate 0 into quotient
|
|||
|
|
mov SI,[BP].align ;Otherwise, subtract divisor
|
|||
|
|
mov DI,SI
|
|||
|
|
mov BX,[BP].dvsr
|
|||
|
|
sub BX,SI
|
|||
|
|
dec BX
|
|||
|
|
dec BX
|
|||
|
|
mov CX,[BP].dvsrsz
|
|||
|
|
clc ;No carry in
|
|||
|
|
divsublp: lodsw
|
|||
|
|
sbb AX,[SI+BX]
|
|||
|
|
stosw
|
|||
|
|
loop divsublp
|
|||
|
|
divbit1: clc ;Clear carry (to rotate 1 in)
|
|||
|
|
divbit0: cmc
|
|||
|
|
mov SI,[BP].quot ;Fetch pointer to quotient
|
|||
|
|
mov CX,[SI]-3 ;Fetch quotient length
|
|||
|
|
quotlp: rcl word ptr[SI],1 ;Rotate bit in
|
|||
|
|
inc SI
|
|||
|
|
inc SI
|
|||
|
|
loop quotlp ;Rotate bits through whole quotient
|
|||
|
|
dec [BP].bitcount ;Last quotient bit rotated in?
|
|||
|
|
jz divdone ;Yes, stop
|
|||
|
|
mov SI,[BP].ldvsr ;Otherwise realign divisor (shr)
|
|||
|
|
mov CX,[BP].dvsrsz
|
|||
|
|
std ;Direction backward
|
|||
|
|
cmp word ptr[SI],0 ;Time to shift divisor words?
|
|||
|
|
jnz wshftskp ;No, don't bother
|
|||
|
|
mov BX,SI ;Save last word pointer
|
|||
|
|
mov DX,CX ;Save word count
|
|||
|
|
mov DI,SI ;Destination = source+2
|
|||
|
|
dec SI
|
|||
|
|
dec SI
|
|||
|
|
dec CX ;Shift significant divisor words
|
|||
|
|
rep movsw
|
|||
|
|
xor AX,AX ;Clear least significant word
|
|||
|
|
stosw
|
|||
|
|
mov SI,BX ;Restore last word pointer
|
|||
|
|
mov CX,DX ;Restore count
|
|||
|
|
sub [BP].align,2 ;Reset divisor alignment
|
|||
|
|
wshftskp: clc ;Shift 0 in
|
|||
|
|
shrlp: rcr word ptr[SI],1 ;Shift
|
|||
|
|
dec SI
|
|||
|
|
dec SI
|
|||
|
|
loop shrlp ;Shift entire divisor
|
|||
|
|
jmp divlp ;After all this, loop 'til division done
|
|||
|
|
divdone: mov BX,[BP].dvdnd ;Fetch dividend pointer
|
|||
|
|
mov DI,[BX]-3 ;Fetch former length of dividend
|
|||
|
|
dec DI ;Put length-1 in CX
|
|||
|
|
mov CX,DI
|
|||
|
|
shl DI,1 ;Point DI to last dividend word
|
|||
|
|
add DI,BX
|
|||
|
|
std ;Direction backward
|
|||
|
|
xor AX,AX ;Pack as in BIGSUB
|
|||
|
|
repe scasw
|
|||
|
|
jz smlskp2
|
|||
|
|
inc CX
|
|||
|
|
smlskp2: inc CX
|
|||
|
|
mov [BX]-3,CX ;Save in bignum size field
|
|||
|
|
mov BX,[BP].quot ;Fetch quotient pointer
|
|||
|
|
mov DI,[BX]-3 ;Point BX+DI to last quotient word
|
|||
|
|
dec DI
|
|||
|
|
shl DI,1
|
|||
|
|
cmp word ptr[BX+DI],0 ;If last word is 0, decrease length
|
|||
|
|
jnz divex
|
|||
|
|
dec word ptr[BX]-3
|
|||
|
|
divex: pop BP ;Restore stack
|
|||
|
|
add SP,8
|
|||
|
|
xor AX,AX ;Return 0
|
|||
|
|
cld ;Clear direction flag
|
|||
|
|
ret
|
|||
|
|
%bigdiv endp
|
|||
|
|
|
|||
|
|
;Compare working divisor to dividend
|
|||
|
|
divcmp proc near
|
|||
|
|
mov DI,[BP].ldvsr ;Get pointer to last divisor word
|
|||
|
|
mov CX,[BP].dvsrsz ;Fetch number of compares to do
|
|||
|
|
mov SI,[BP].align ;Get dividend pointer
|
|||
|
|
mov AX,CX ;Save # of wrods for pointer adjust
|
|||
|
|
cmp SI,[BP].dvdnd ;Dividend longer than divisor?
|
|||
|
|
jae adjskp ;Yes, jump
|
|||
|
|
dec CX ;Don't compare first divisor word
|
|||
|
|
adjskp: dec AX ;Adjust pointer into dividend
|
|||
|
|
shl AX,1
|
|||
|
|
add SI,AX
|
|||
|
|
mov BX,DI ;Save pointer to last divisor byte
|
|||
|
|
std ;Direction backward
|
|||
|
|
repz cmpsw ;Compare until unequal
|
|||
|
|
ret
|
|||
|
|
divcmp endp
|
|||
|
|
|
|||
|
|
PROGX ends
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
PGROUP group prog
|
|||
|
|
prog segment byte public 'PROG'
|
|||
|
|
assume CS:PGROUP
|
|||
|
|
|
|||
|
|
public big2flo
|
|||
|
|
big2flo proc near
|
|||
|
|
call %big2flo
|
|||
|
|
ret
|
|||
|
|
big2flo endp
|
|||
|
|
|
|||
|
|
public fix2big
|
|||
|
|
fix2big proc near
|
|||
|
|
call %fix2big
|
|||
|
|
ret
|
|||
|
|
fix2big endp
|
|||
|
|
|
|||
|
|
public magcomp
|
|||
|
|
magcomp proc near
|
|||
|
|
call %magcomp
|
|||
|
|
ret
|
|||
|
|
magcomp endp
|
|||
|
|
|
|||
|
|
public bigadd
|
|||
|
|
bigadd proc near
|
|||
|
|
call %bigadd
|
|||
|
|
ret
|
|||
|
|
bigadd endp
|
|||
|
|
|
|||
|
|
public bigsub
|
|||
|
|
bigsub proc near
|
|||
|
|
call %bigsub
|
|||
|
|
ret
|
|||
|
|
bigsub endp
|
|||
|
|
|
|||
|
|
public bigmul
|
|||
|
|
bigmul proc near
|
|||
|
|
call %bigmul
|
|||
|
|
ret
|
|||
|
|
bigmul endp
|
|||
|
|
|
|||
|
|
public bigdiv
|
|||
|
|
bigdiv proc near
|
|||
|
|
call %bigdiv
|
|||
|
|
ret
|
|||
|
|
bigdiv endp
|
|||
|
|
|
|||
|
|
prog ends
|
|||
|
|
end
|
|||
|
|
|