Category : A Collection of Games for DOS and Windows
Archive   : EMPIREU.ZIP
Filename : PATCHES.ASM

TITLE PATCHES

PAGE 44,132

PUBLIC PATCH, PATCHES_INSTALLED

DATA SEGMENT PUBLIC

MDONE DB ' (patches applied) $'
MSTART DB 13,10,'Begin applying patches',13,10,'$'
MWRONG DB 'Got the wrong answer',13,10
DB 'Try re-booting',13,10,'$'

MSLOC DB 'Locating reference segment',13,10,'$'
SDESC DW 3E85H,0010H,0035H,DATA,UNIQTX,UNIQTX_END-1
UNIQTX DB 'VERSION',0,9,9,'EMPIRE v5.00RB Release 1.1',0,0AH
UNIQTX_END LABEL BYTE

M28AA_06E8 DB 'Replacing function ON_EDGE',13,10,'$'
PP28AA_06E8 DW 28AAH,06E8H,071EH
DW SEG P28AA_06E8,P28AA_06E8,P28AA_06E8_END-1

M28AA_071F DB 'Replacing function PICK_DIRECTION',13,10,'$'
PP28AA_071F DW 28AAH,071FH,0973H
DW SEG P28AA_071F,P28AA_071F,P28AA_071F_END-1

M3527_080F DB 'Replacing function FOLD8',13,10,'$'
PP3527_080F DW 3527H,080FH,083AH
DW SEG P3527_080F,P3527_080F,P3527_080F_END-1

M3527_089A DB 'Improving routine at 3527:089A..0BAB',13,10,'$'
PA3527_090C DW 3527H,090CH,093FH
DW SEG A3527_090C,A3527_090C,A3527_090C_END-1
PA3527_0951 DW 3527H,0951H,096BH
DW SEG A3527_0951,A3527_0951,A3527_0951_END-1
PA3527_0A22 DW 3527H,0A22H,0A3CH
DW SEG A3527_0A22,A3527_0A22,A3527_0A22_END-1
PA3527_0A84 DW 3527H,0A84H,0AA7H
DW SEG A3527_0A84,A3527_0A84,A3527_0A84_END-1
PA3527_0B10 DW 3527H,0B10H,0B2AH
DW SEG A3527_0B10,A3527_0B10,A3527_0B10_END-1
PA3527_0B58 DW 3527H,0B58H,0B71H
DW SEG A3527_0B58,A3527_0B58,A3527_0B58_END-1
PA3527_0B82 DW 3527H,0B82H,0B9DH
DW SEG A3527_0B82,A3527_0B82,A3527_0B82_END-1

M3527_0BAE DB 'Replacing function MATCHES',13,10,'$'
PP3527_0BAE DW 3527H,0BAEH,0CA8H
DW SEG P3527_0BAE,P3527_0BAE,P3527_0BAE_END-1

M3A64_0249 DB 'Replacing floating-point add',13,10,'$'
PP3A64_0249 DW 3A64H,0249H,030AH
DW SEG P3A64_0249_XFER,P3A64_0249_XFER,P3A64_0249_XFER_END-1

M3A64_013E DB 'Replacing floating-point normalization',13,10,'$'
PP3A64_013E DW 3A64H,013EH,019BH
DW SEG P3A64_013E_XFER,P3A64_013E_XFER,P3A64_013E_XFER_END-1

DATA ENDS


PATCH_SEG SEGMENT PUBLIC

ASSUME CS : PATCH_SEG

public count_total, count_zero, count_left, count_right
count_total dw 0,0
count_zero dw 0,0
count_left dw 0,0
count_right dw 0,0

inc_total proc far
inc count_total
jnz inc_total_ret
inc count_total+2
inc_total_ret:
ret
inc_total endp

inc_zero proc far
inc count_zero
jnz inc_zero_ret
inc count_zero+2
inc_zero_ret:
ret
inc_zero endp

inc_left proc far
inc count_left
jnz inc_left_ret
inc count_left+2
inc_left_ret:
ret
inc_left endp

inc_right proc far
inc count_right
jnz inc_right_ret
inc count_right+2
inc_right_ret:
ret
inc_right endp


P3A64_00CC PROC NEAR ; 3A64:00CC..00D8
; save all registers
PUSH ES
PUSH AX
PUSH BX
PUSH CX
PUSH DX
PUSH SI
PUSH DI
PUSH BP
MOV BP,SP
JMP [BP+10H]
P3A64_00CC ENDP


P3A64_00D9 PROC NEAR ; 3A64:00D9..00E6
; restore all registers
POP [BP+10H]
MOV SP,BP
POP BP
POP DI
POP SI
POP DX
POP CX
POP BX
POP AX
POP ES
RET
P3A64_00D9 ENDP


P3A64_00E7 PROC NEAR ; 3A64:00E7..00F2
; copy CX words from
; SS:SI to SS:DI
CLD
MOV AX,SS
MOV ES,AX
PUSH DS
MOV DS,AX
REPZ MOVSW
POP DS
RET
P3A64_00E7 ENDP


P3A64_00F3 PROC NEAR ; 3A64:00F3..011E
; unpack floating-point from
; 4-word to 6-word
ADD DI,4
MOVSW ; [orig DI + 4]
MOVSW ; [orig DI + 6]
MOVSW ; [orig DI + 8]
LODSW
MOV BX,AX
AND AX,000FH
OR AX,0010H
STOSW ; [orig DI + A]
SUB DI,0CH
MOV AX,BX
AND AX,8000H
STOSW ; [orig DI]
MOV AX,BX
AND AX,7FF0H
STOSW ; [orig DI + 2]
RET
P3A64_00F3 ENDP


P3A64_011F PROC NEAR ; 3A64:011F..013D
; pack floating-point from
; 6-word to 4-word
LODSW ; [orig SI]
MOV BX,AX
LODSW ; [orig SI + 2]
OR BX,AX
MOVSW ; [orig SI + 4] ==> [orig DI]
MOVSW ; [orig SI + 6] ==> [orig DI + 2]
MOVSW ; [orig SI + 8] ==> [orig DI + 4]
LODSW ; [orig SI + A]
AND AX,000FH
OR AX,BX
STOSW ; [orig DI + 6]
RET
P3A64_011F ENDP

; These are up here to try to make
; the puny jump-conditional reach

SHIFT_CH:
; shift CH up to AL
MOV AL,CH
MOV BH,CL
MOV BL,DH
MOV CH,DL
MOV CL,0
MOV DX,0
SUB SI,180H
JMP RIGHT_AS_NEEDED

CX_NONZERO:
CMP CH,0
JNZ SHIFT_CH

; shift CL up to AL
MOV AL,CL
MOV BX,DX
MOV CL,0
MOV DX,0
SUB SI,200H
JMP RIGHT_AS_NEEDED

SHIFT_DH: ; shift DH up to AL
MOV AL,DH
MOV BH,DL
MOV DX,0
SUB SI,280H
JMP RIGHT_AS_NEEDED

ALL_ZERO:
MOV SS:[DI],AX
MOV SS:[DI+02],AX
JMP L019B

P3A64_013E_NEW PROC FAR ; 3A64:013E..019B
PUSH CX ; I don't think it matters, but I'm chicken
PUSH DX
PUSH SI
MOV AX,SS:[DI+0AH]
MOV BX,SS:[DI+08H]
MOV CX,SS:[DI+06H]
MOV DX,SS:[DI+04H]
MOV SI,SS:[DI+02H]

; shift bytes or words to get first (leftmost) non-zero
; byte in AL

; bias to do best when DL is only non-zero byte

CMP AX,0
JNZ AX_NONZERO
CMP BX,0
JNZ BX_NONZERO
CMP CX,0
JNZ CX_NONZERO
CMP DH,0
JNZ SHIFT_DH
CMP DL,0
JZ ALL_ZERO

; shift DL up to AL
MOV AL,DL
MOV DL,0
SUB SI,300H

; shift right as needed
RIGHT_AS_NEEDED:
TEST AX,0FFE0H
JZ LEFT_AS_NEEDED
RIGHT_AGAIN:
SHR AX,1
RCR BX,1
RCR CX,1
RCR DX,1
ADD SI,10H
TEST AX,0FFE0H
JNZ RIGHT_AGAIN
; done
PUTEMBACK:
MOV SS:[DI+0AH],AX
MOV SS:[DI+08H],BX
MOV SS:[DI+06H],CX
MOV SS:[DI+04H],DX
MOV SS:[DI+02H],SI
L019B: POP SI
POP DX
POP CX
RET

; shift left as needed
LEFT_AS_NEEDED:
TEST AX,10H
JNZ PUTEMBACK
LEFT_AGAIN:
SHL DX,1
RCL CX,1
RCL BX,1
RCL AX,1
SUB SI,10H
TEST AX,10H
JZ LEFT_AGAIN
JMP PUTEMBACK

AX_NONZERO:
CMP AH,0
JZ RIGHT_AS_NEEDED
; shift AH to AL
MOV DL,DH
MOV DH,CL
MOV CL,CH
MOV CH,BL
MOV BL,BH
MOV BH,AL
MOV AL,AH
MOV AH,0
ADD SI,80H
JMP RIGHT_AS_NEEDED

BX_NONZERO:
CMP BH,0
JNZ SHIFT_BH
; shift BL up to AL
MOV AL,BL
MOV BX,CX
MOV CX,DX
MOV DX,0
SUB SI,100H
JMP RIGHT_AS_NEEDED

SHIFT_BH: ; shift BH up to AL
MOV AL,BH
MOV BH,BL
MOV BL,CH
MOV CH,CL
MOV CL,DH
MOV DH,DL
MOV DL,0
SUB SI,80H
JMP RIGHT_AS_NEEDED
P3A64_013E_NEW ENDP

P3A64_0249_NEW PROC FAR ; 3A64:0249..030A

PUSH DS ; save all registers
PUSH ES
PUSH AX
PUSH BX
PUSH CX
PUSH DX
PUSH SI
PUSH DI
PUSH BP
MOV BP,SP
MOV AX,SS
MOV ES,AX
MOV DS,AX
CLD
MOV AX,7FF0H
TEST [BP+1CH],AX
JZ L0265
TEST [BP+24H],AX
JNZ L0268
MOV CX,0004
LEA SI,[BP+16H]
LEA DI,[BP+1EH]
REP MOVSW ; CALL P3A64_00E7 ; copy
L0265: JMP L02F9

L0268: SUB SP,+18H
LEA SI,[BP+16H]
MOV DI,SP
CALL P3A64_00F3 ; unpack floating-point
LEA SI,[BP+1EH]
LEA DI,[BP-0CH]
CALL P3A64_00F3 ; unpack floating-point
; make SI point to larger
; exponent
; DI point to smaller
; adjust DI to same exponent
MOV SI,SP
LEA DI,[BP-0CH]
MOV AX,[SI+02]
SUB AX,[DI+02]
JZ L02A9
JNS L0291
XCHG DI,SI
NEG AX
L0291: ADD [DI+02],AX
MOV CL,04
SHR AX,CL
MOV CX,AX
;L029B: MOV BX,0006
; CLC
;L029F: RCR Word Ptr SS:[BX+DI+04],1
; DEC BX
; DEC BX
; JNS L029F
PUSH SI
MOV AX,[DI+0AH]
MOV BX,[DI+08H]
MOV SI,[DI+06H]
MOV DX,[DI+04H]
; study shows half the time the adjustment is 8 bits or more
; never observed 16 bits or more
CMP CX,8
JL L029B
XCHG SI,CX
MOV DL,DH
MOV DH,CL
MOV CL,CH
MOV CH,BL
MOV BL,BH
MOV BH,AL
MOV AL,AH
XCHG SI,CX
SUB CX,8
JZ STORE_ADJUSTED
L029B:
SHR AX,1
RCR BX,1
RCR SI,1
RCR DX,1
LOOP L029B
STORE_ADJUSTED:
MOV [DI+0AH],AX
MOV [DI+08H],BX
MOV [DI+06H],SI
MOV [DI+04H],DX
POP SI

L02A9: MOV CX,0004
MOV BX,CX
; if same sign...
MOV AX,[DI]
XOR AX,[SI]
JS L02C4

CLC
L02B7: MOV AX,[BX+SI]
ADC [BX+DI],AX
INC BX
INC BX
LOOP L02B7
JMP L02EE

NOP

L02C4: CLC
L02C5: MOV AX,[BX+SI]
SBB [BX+DI],AX
INC BX
INC BX
LOOP L02C5
MOV AX,[DI+0AH]
OR AX,AX
JNS L02EE
XOR AX,AX
MOV CX,0004
MOV BX,CX
STC
L02DF: NOT Word Ptr [BX+DI]
ADC [BX+DI],AX
INC BX
INC BX
LOOP L02DF
MOV AH,80H
XOR [DI],AX

L02EE: PUSH DI
CALL P3A64_013E_NEW ; normalize answer
POP SI
LEA DI,[BP+1EH]
CALL P3A64_011F ; pack floating-point
L02F9: TEST Word Ptr [BP+24H],7FF0H
JNZ L0305
MOV Word Ptr [BP+24H],0000H
L0305: ; restore all registers
MOV SP,BP
POP BP
POP DI
POP SI
POP DX
POP CX
POP BX
POP AX
POP ES
POP DS
RET 0008

P3A64_0249_NEW ENDP

PATCH_SEG ENDS



CODE SEGMENT PUBLIC

ASSUME CS : CODE
ASSUME DS : DATA

EXTRN CHECK_OPTION : NEAR
EXTRN IPATCH : NEAR
EXTRN LOCSEG : NEAR
EXTRN PLMSG : NEAR
EXTRN SET_PLOG : NEAR


P28AA_06E8 PROC FAR ; replace routine at 28AA:06E8..071E
; function ON_EDGE ( MAPINDEX : INTEGER ) : BOOLEAN ;
; begin
MOV SI,SP
; if (MAPINDEX <= 101)
MOV AX,SS:[SI+4]
CMP AX,65H
JLE ON_EDGE_TRUE
; or (MAPINDEX >= 5900) then
; ON_EDGE := TRUE
CMP AX,170CH
JGE ON_EDGE_TRUE
; else if MAPINDEX mod 100 <= 1 then
; ON_EDGE := TRUE
CWD
MOV CX,64H
IDIV CX
CMP DX,1
JLE ON_EDGE_TRUE
; else ON_EDGE := FALSE
MOV AX,0
RET
; end ;
ON_EDGE_TRUE:
MOV AX,1
RET
P28AA_06E8 ENDP
P28AA_06E8_END LABEL BYTE



P28AA_071F PROC FAR ; replace routine at 28AA:071F..0973
; var
; G1D8E : REAL ;
; function PICK_DIRECTION(ARG1, ARG2 : INTEGER ) : INTEGER ;
; var LOCM03, RDELTA, LOCM07, LOCM09, COL1, COL2, ROW1M1, ROW2M1,
; LOCM13, LOCM3E, CDELTA : INTEGER ;
PUSH BP
MOV BP,SP
SUB SP,+58H
; ROW2M1 := (ARG2-1) div 100 ;
; ROW1M1 := (ARG1-1) div 100 ;
; COL2 := ARG2 - ROW2M1*100 ;
; COL1 := ARG1 - ROW1M1*100 ;
; RDELTA := ROW1M1 - ROW2M1 ;
; CDELTA := COL1 - COL2 ;
MOV BX,64H
MOV AX,[BP+6]
DEC AX
CWD
IDIV BX
MOV [BP-11H],AX
INC DX
MOV [BP-0DH],DX
MOV AX,[BP+8]
DEC AX
CWD
IDIV BX
MOV [BP-0FH],AX
INC DX
MOV [BP-0BH],DX
SUB AX,[BP-11H]
MOV [BP-05H],AX
MOV AX,[BP-0BH]
SUB AX,[BP-0DH]
MOV [BP-42H],AX
; if CDELTA = 0 then
CMP WORD PTR [BP-42H],0
JNZ IF1ELSE1
; begin
; if RDELTA < 0 then
CMP WORD PTR [BP-05H],0
JGE IF11ELSE1
; LOCM03 := -100
MOV WORD PTR [BP-03H],-64H
JMP L0939
; else LOCM03 := 100 ;
IF11ELSE1:
MOV WORD PTR [BP-03H],64H
JMP L0939
; end
; else if RDELTA = 0 then
IF1ELSE1:
CMP WORD PTR [BP-05H],0
JNZ IF1ELSE2
; begin
; if CDELTA < 0 then
CMP WORD PTR [BP-42H],0
JGE IF12ELSE1
; LOCM03 := -1
MOV WORD PTR [BP-03H],-1
JMP L0939
; else LOCM03 := 1 ;
IF12ELSE1:
MOV WORD PTR [BP-03H],1
JMP L0939
; end
; else
IF1ELSE2:
; begin
; LOCM07 := abs(CDELTA) ;
MOV AX,[BP-42H]
CMP AX,0
JGE ABSLOCM42DONE
NEG AX
ABSLOCM42DONE:
; LOCM09 := abs(RDELTA) ;
MOV DX,[BP-05H]
CMP DX,0
JGE ABSLOCM05DONE
NEG DX
ABSLOCM05DONE:
; LOCM13 := 1 ;
MOV WORD PTR [BP-13H],1
; if LOCM09 > LOCM07 then
CMP DX,AX
JLE CMP0907DONE
; begin
; LOCM07 := LOCM09 ;
; LOCM09 := abs(CDELTA) ;
XCHG DX,AX
; LOCM13 := 0 ;
MOV WORD PTR [BP-13H],0
; end ;
CMP0907DONE:
MOV [BP-09H],DX
MOV [BP-07H],AX
; if float(LOCM07*10 div 3) + G1D8E > float(LOCM09*10) then
; and I really believe G1D8E is always 0.5
; so question becomes "is LOCM07*10 div 3 >= LOCM09*10 ?"
; { i.e., "is LOCM07 a whole lot bigger than LOCM09?" }
; sufficient to evaluate "LOCM07 >= LOCM09*3"
MOV BX,DX
ADD BX,DX
ADD BX,DX
CMP AX,BX
JL L08E0
; if LOCM13 <> 0 then
CMP WORD PTR [BP-13H],0
JZ IF5ELSE1
; if CDELTA < 0 then
CMP WORD PTR [BP-42H],0
JGE IF6ELSE1
; LOCM03 := -1
MOV WORD PTR [BP-03H],-1
JMP L0939
; else LOCM03 := 1 ;
IF6ELSE1:
MOV WORD PTR [BP-03H],1
JMP L0939
; else if RDELTA < 0 then
IF5ELSE1:
CMP WORD PTR [BP-05H],0
JGE IF5ELSE2
; LOCM03 := -100
MOV WORD PTR [BP-03H],-64H
JMP L0939
; else LOCM03 := 100 ;
IF5ELSE2:
MOV WORD PTR [BP-03H],64H
JMP L0939
; else
L08E0:
; begin
; if RDELTA < 0 then
; AX := -100
; else AX := 100 ;
MOV AX,64H
CMP WORD PTR [BP-05],0
JGE IF7END
NEG AX
IF7END:
; if CDELTA < 0 then
; DX := -1
; else DX := 1 ;
MOV DX,1
CMP WORD PTR [BP-42H],0
JGE IF8END
NEG DX
IF8END:
; LOCM03 := AX + DX ;
ADD AX,DX
MOV [BP-03],AX
; end ;
; end ;
L0939:
; LOCM3E := 1 ;
; while (LOCM3E <= 9)
; and (W1D6A[LOCM3E] <> LOCM03) do
; LOCM3E := LOCM3E + 1 ;
MOV CX,9
MOV BX,1D6AH
MOV AX,[BP-03]
LOOP1:
ADD BX,2
CMP AX,[BX]
LOOPNE LOOP1
JZ LOOP1FIXEDUP
DEC CX
LOOP1FIXEDUP:
MOV AX,8
SUB AX,CX
; return LOCM3E-1 ;
MOV SP,BP
POP BP
RET
P28AA_071F ENDP
P28AA_071F_END LABEL BYTE


P3527_080F PROC FAR ; replace routine at 3527:080F..083A
; function FOLD8(ARG : INTEGER) : INTEGER ;
; begin
MOV SI,SP
; if ARG > 8 then
; FOLD8 := ARG - 8
MOV AX,SS:[SI+4]
MOV CX,8
SUB AX,CX
JG FOLD8_RETURN
; else if ARG < 1 then
; FOLD8 := ARG + 8
; else FOLD8 := ARG
ADD AX,CX
JG FOLD8_RETURN
ADD AX,CX
; end ;
FOLD8_RETURN:
RET
P3527_080F ENDP
P3527_080F_END LABEL BYTE


P3527_089A PROC FAR ; improve routine at 3527:089A..0BAB

A3527_090C:
MOV AX,SS
MOV ES,AX
LEA DI,[BP+0FF19H+2]
MOV CX,64H
MOV AX,0
REP STOSW
JMP 0940H+A3527_090C-090CH
A3527_090C_END LABEL BYTE

A3527_0951:
INC AX
SHL AX,1
MOV SI,AX
MOV AX,[SI+1D6AH]
JMP 096CH+A3527_0951-0951H
A3527_0951_END LABEL BYTE

A3527_0A22:
INC AX
SHL AX,1
MOV SI,AX
MOV AX,[SI+1D6AH]
JMP 0A3DH+A3527_0A22-0A22H
A3527_0A22_END LABEL BYTE

A3527_0A84:
MOV SI,AX
INC SI
SHL SI,1
MOV AX,[SI+1D6AH]
ADD AX,[BP-1DH]
MOV [BP-1BH],AX
PUSH AX
JMP 0AA8H+A3527_0A84-0A84H
A3527_0A84_END LABEL BYTE

A3527_0B10:
INC AX
SHL AX,1
MOV SI,AX
MOV AX,[SI+1D6AH]
JMP 0B2BH+A3527_0B10-0B10H
A3527_0B10_END LABEL BYTE

A3527_0B58:
MOV SI,[BP-05]
SHL SI,1
LEA AX,[BP+0FF19H]
ADD SI,AX
MOV AX,SS:[SI]
JMP 0B72H+A3527_0B58-0B58H
A3527_0B58_END LABEL BYTE

A3527_0B82:
LEA BX,[BP+0FF19H]
MOV SI,[BP-0DH]
SHL SI,1
ADD SI,BX
MOV SS:[SI],AX
JMP 0B9EH+A3527_0B82-0B82H
A3527_0B82_END LABEL BYTE

P3527_089A ENDP


; var
; G9423 : array [1..?] of BYTE ;
; G4DD0 : array [1..?] of BYTE ;
P3527_0BAE PROC FAR ; replace routine at 3527:0BAE..0CA8
; function MATCHES(consts ARG1 : INTEGER_ARRAY ; ARG2 : INTEGER ) : BOOLEAN ;
; var
; LOCM18 : INTEGER ;
; begin
MOV DI,SP ; DI: SP
; LOCM18 := ord(G4DD0[ARG2]) ;
MOV SI,SS:[DI+4] ; SI: ARG2
MOV AL,[SI+4DCFH] ; AX: LOCM18
CBW
; if ARG1[2] = LOCM18 then
; MATCHES := TRUE
MOV ES,SS:[DI+8] ; ES:BX: ARG1[1]
MOV BX,SS:[DI+6]
MOV DX,ES:[BX+2] ; DX: ARG1[2]
CMP DX,AX
JZ MATCHES_TRUE
; else if ARG1[2] = ord(G9423[ARG2]) then
; MATCHES := TRUE
MOV CX,AX ; CX: LOCM18
MOV AL,[SI+9422H] ; AX: ord(G9423[ARG2])
CBW
CMP DX,AX
JZ MATCHES_TRUE
; else if ARG1[3] = LOCM18 then
; MATCHES := TRUE
CMP ES:[BX+4],CX
JZ MATCHES_TRUE
; else ARG1[4] = LOCM18 then
; MATCHES := TRUE
CMP ES:[BX+6],CX
JZ MATCHES_TRUE
; else if ARG1[5] = LOCM18 then
; MATCHES := TRUE
CMP ES:[BX+8],CX
JZ MATCHES_TRUE
; else if ARG1[6] = LOCM18 then
; MATCHES := TRUE
CMP ES:[BX+0AH],CX
JZ MATCHES_TRUE
; else MATCHES := FALSE
MOV AX,0
RET
; end ;
MATCHES_TRUE:
MOV AX,1
RET
P3527_0BAE ENDP
P3527_0BAE_END LABEL BYTE

P3A64_013E_XFER PROC NEAR ; replace routine at 3A64:013E..019B
; routine is a NEAR PROC
CALL P3A64_013E_NEW
RET
P3A64_013E_XFER ENDP
P3A64_013E_XFER_END LABEL BYTE

P3A64_0249_XFER PROC FAR ; replace routine at 3A64:0249..030A
; original is FAR PROC so can just jump to it
JMP P3A64_0249_NEW
P3A64_0249_XFER ENDP
P3A64_0249_XFER_END LABEL BYTE

PATCH PROC ; Apply Patches
PUSH AX
PUSH DS
PUSH DX
PUSH ES
PUSH SI

MOV AX,DATA
MOV DS,AX

MOV AL,'L' ; see if to print log messages
CALL CHECK_OPTION
CALL SET_PLOG ; tell patch utility

MOV DX,OFFSET MSTART
CALL PLMSG

MOV DX,OFFSET MSLOC
MOV SI,OFFSET SDESC
CALL SWANTNC

MOV DX,OFFSET M28AA_06E8
MOV SI,OFFSET PP28AA_06E8
CALL PWANTNC

MOV DX,OFFSET M28AA_071F
MOV SI,OFFSET PP28AA_071F
CALL PWANTNC

MOV DX,OFFSET M3527_080F
MOV SI,OFFSET PP3527_080F
CALL PWANTNC

MOV DX,OFFSET M3527_089A
MOV SI,OFFSET PA3527_090C
CALL PWANTNC
MOV SI,OFFSET PA3527_0951
CALL PWANTNC
MOV SI,OFFSET PA3527_0A22
CALL PWANTNC
MOV SI,OFFSET PA3527_0A84
CALL PWANTNC
MOV SI,OFFSET PA3527_0B10
CALL PWANTNC
MOV SI,OFFSET PA3527_0B58
CALL PWANTNC
MOV SI,OFFSET PA3527_0B82
CALL PWANTNC

MOV DX,OFFSET M3527_0BAE
MOV SI,OFFSET PP3527_0BAE
CALL PWANTNC

MOV DX,OFFSET M3A64_0249
MOV SI,OFFSET PP3A64_0249
CALL PWANTNC

MOV DX,OFFSET M3A64_013E
MOV SI,OFFSET PP3A64_013E
CALL PWANTNC

MOV AH,9
MOV DX,OFFSET MDONE
INT 21H
PATCHES_INSTALLED:
POP SI
POP ES
POP DX
POP DS
POP AX
RET
PATCH ENDP

PWANTNC PROC ; Patch and expect NO CARRY
; DX = introductory message
; DS:SI = pointer to patch descriptor
PUSH AX
PUSH ES
CALL PLMSG
MOV AX,DS
MOV ES,AX
CALL IPATCH
JNC PWANTNC_EXIT
CALL WRONG
PWANTNC_EXIT:
POP ES
POP AX
RET
PWANTNC ENDP

SWANTNC PROC ; Locate segment and expect NO CARRY
; DX = introductory message
; DS:SI = pointer to segment descriptor
PUSH AX
PUSH ES
CALL PLMSG
MOV AX,DS
MOV ES,AX
CALL LOCSEG
JNC SWANTNC_EXIT
CALL WRONG
MOV AH,4CH ; it's too risky to keep going
INT 21H
SWANTNC_EXIT:
POP ES
POP AX
RET
SWANTNC ENDP

WRONG PROC ; Got wrong answer
PUSH AX
PUSH DX
MOV AH,9
MOV DX,OFFSET MWRONG
INT 21H
POP DX
POP AX
RET
WRONG ENDP

CODE ENDS

END