TITLE   DEBASM

; Code for the ASSEMble command in the debugger

.xlist
.xcref
        INCLUDE DEBEQU.ASM
        INCLUDE DOSSYM.ASM
.cref
.list


CODE    SEGMENT PUBLIC BYTE 'CODE'
CODE    ENDS

CONST   SEGMENT PUBLIC BYTE

        EXTRN   DBMN:BYTE,CSSAVE:WORD,REG8:BYTE,REG16:BYTE,SIZ8:BYTE
        EXTRN   SYNERR:BYTE,OPTAB:BYTE,MAXOP:ABS

CONST   ENDS

DATA    SEGMENT PUBLIC BYTE

        EXTRN   HINUM:WORD,LOWNUM:WORD,ASSEM_CNT:BYTE
        EXTRN   ASSEM1:BYTE,ASSEM2:BYTE,ASSEM3:BYTE,ASSEM4:BYTE,ASSEM5:BYTE
        EXTRN   ASSEM6:BYTE,OPBUF:BYTE,OPCODE:WORD,REGMEM:BYTE,INDEX:WORD
        EXTRN   ASMADD:BYTE,ASMSP:WORD,MOVFLG:BYTE,SEGFLG:BYTE,TSTFLG:BYTE
        EXTRN   NUMFLG:BYTE,DIRFLG:BYTE,BYTEBUF:BYTE,F8087:BYTE,DIFLG:BYTE
        EXTRN   SIFLG:BYTE,BXFLG:BYTE,BPFLG:BYTE,NEGFLG:BYTE,MEMFLG:BYTE
        EXTRN   REGFLG:BYTE,AWORD:BYTE,MIDFLD:BYTE,MODE:BYTE

DATA    ENDS

DG      GROUP   CODE,CONST,DATA


CODE    SEGMENT PUBLIC BYTE 'CODE'
ASSUME  CS:DG,DS:DG,ES:DG,SS:DG

        PUBLIC  ASSEM
        PUBLIC  DB_OPER,DW_OPER,ASSEMLOOP,GROUP2,AA_OPER,DCINC_OPER
        PUBLIC  GROUP1,ESC_OPER,FGROUPP,FGROUPX,FDE_OPER,FGROUPZ
        PUBLIC  FD9_OPER,FGROUP,FDB_OPER,FGROUPB,FGROUP3,FGROUP3W
        PUBLIC  FGROUPDS,INT_OPER,IN_OPER,DISP8_OPER,JMP_OPER,NO_OPER
        PUBLIC  OUT_OPER,L_OPER,MOV_OPER,POP_OPER,PUSH_OPER,ROTOP
        PUBLIC  TST_OPER,EX_OPER,GET_DATA16,CALL_OPER

        EXTRN   INBUF:NEAR,SCANB:NEAR,SCANP:NEAR,GETHX:NEAR,GET_ADDRESS:NEAR
        EXTRN   DEFAULT:NEAR,OUTDI:NEAR,BLANK:NEAR,PRINTMES:NEAR,TAB:NEAR

;
;       Line by line assembler
;

ASSEM:
        MOV     BP,[CSSAVE]             ; Default code segment
        MOV     DI,OFFSET DG:ASMADD     ; Default address
        CALL    DEFAULT
        MOV     WORD PTR [ASMADD],DX    ; Displacement of disassembly
        MOV     WORD PTR [ASMADD+2],AX  ; Segment
        MOV     [ASMSP],SP              ; Save sp in case of error

ASSEMLOOP:
        MOV     SP,[ASMSP]              ; Restore sp in case of error
        LES     DI,DWORD PTR ASMADD     ; GET PC
        CALL    OUTDI                   ; OUTPUT ADDRESS
        CALL    BLANK                   ; SKIP A SPACE
        PUSH    CS
        POP     ES
        CALL    INBUF                   ; GET A BUFFER
        CALL    SCANB
        JNZ     OPLOOK
        RET                             ; IF EMPTY JUST RETURN
;
;  At this point ds:si points to the opcode mnemonic...
;
OPLOOK: XOR     CX,CX                   ; OP-CODE COUNT = 0
        MOV     DI,OFFSET DG:DBMN
OPSCAN: XOR     BX,BX
OPLOOP: MOV     AL,[DI+BX]
        AND     AL,7FH
        CMP     AL,[SI+BX]
        JZ      OPMATCH
        INC     CX                      ; INCREMENT OP-CODE COUNT
        CMP     CX,MAXOP                ; CHECK FOR END OF LIST
        JB      OP1
        JMP     ASMERR
OP1:    INC     DI                      ; SCAN FOR NEXT OP-CODE...
        TEST    BYTE PTR [DI-1],80H
        JZ      OP1
        JMP     OPSCAN

OPMATCH:INC     BX                      ; COMPARE NEXT CHAR
        TEST    BYTE PTR [DI+BX-1],80H  ; ARE WE DONE?
        JZ      OPLOOP                  ; ..IF NOT KEEP COMPARING
        XCHG    BX,CX
        MOV     AX,BX
        SHL     AX,1
        ADD     AX,BX
        ADD     AX,OFFSET DG:OPTAB
        MOV     BX,AX
;
; CX = COUNT OF CHARS IN OPCODE
; BX = POINTER INTO OPCODE TABLE
;
        XOR     AX,AX
        MOV     BYTE PTR [AWORD],AL
        MOV     WORD PTR [MOVFLG],AX    ; MOVFLG + TSTFLG
        MOV     BYTE PTR [SEGFLG],AL    ; ZERO SEGMENT REGISTER FLAG
        MOV     AH,00001010B            ; SET UP FOR AA_OPER
        MOV     AL,BYTE PTR [BX]
        MOV     WORD PTR [ASSEM1],AX
        MOV     BYTE PTR [ASSEM_CNT],1

        ADD     SI,CX                   ; SI POINTS TO OPERAND
        JMP     WORD PTR [BX+1]
;
; 8087 INSTRUCTIONS WITH NO OPERANDS
;
FDE_OPER:
        MOV     AH,0DEH
        JMP     SHORT FDX_OPER
FDB_OPER:
        MOV     AH,0DBH
        JMP     SHORT FDX_OPER
FD9_OPER:
        MOV     AH,0D9H
FDX_OPER:
        XCHG    AL,AH
        MOV     WORD PTR [ASSEM1],AX
;
;  aad and aam instrucions
;
AA_OPER:INC     BYTE PTR [ASSEM_CNT]
;
;  instructions with no operands
;
NO_OPER:
        CALL    STUFF_BYTES
        CALL    SCANP
        PUSH    CS
        POP     ES
        JNZ     OPLOOK
        JMP     ASSEMLOOP
;
;  push instruction
;
PUSH_OPER:
        MOV     AH,11111111B
        JMP     SHORT POP1
;
;  pop instruction
;
POP_OPER:
        MOV     AH,10001111B
POP1:   MOV     [ASSEM1],AH
        MOV     [MIDFLD],AL
        INC     BYTE PTR [MOVFLG]       ; ALLOW SEGMENT REGISTERS
        MOV     BYTE PTR [AWORD],2      ; MUST BE 16 BITS
        CALL    GETREGMEM
        CALL    BUILDIT
        MOV     AL,[DI+2]
        CMP     AL,11000000B
        JB      DATRET
        MOV     BYTE PTR [DI],1
        CMP     BYTE PTR [MOVFLG],2
        JNZ     POP2
        AND     AL,00011000B
        OR      AL,00000110B
        CMP     BYTE PTR [MIDFLD],0
        JNZ     POP3
        OR      AL,00000001B
        JMP     SHORT POP3

POP2:   AND     AL,111B
        OR      AL,01010000B
        CMP     BYTE PTR [MIDFLD],0
        JNZ     POP3
        OR      AL,01011000B
POP3:   MOV     BYTE PTR [DI+1],AL
        JMP     ASSEM_EXIT
;
; ret and retf instructions
;
GET_DATA16:
        CALL    SCANB
        MOV     CX,4
        CALL    GETHX
        JC      DATRET
        DEC     BYTE PTR [ASSEM1]       ; CHANGE OP-CODE
        ADD     BYTE PTR [ASSEM_CNT],2  ; UPDATE LENGTH
        MOV     WORD PTR [ASSEM2],DX    ; SAVE OFFSET
DATRET: JMP     ASSEM_EXIT
;
;  int instruction
;
INT_OPER:
        CALL    SCANB
        MOV     CX,2
        CALL    GETHX
        JC      ERRV1
        MOV     AL,DL
        CMP     AL,3
        JZ      DATRET
        INC     BYTE PTR [ASSEM1]
        JMP     DISPX
;
;  in instruction
;
IN_OPER:
        CALL    SCANB
        LODSW
        CMP     AX,"A"+4C00H            ; "AL"
        JZ      IN_1
        CMP     AX,"A"+5800H            ; "AX"
        JZ      IN_0
ERRV1:  JMP     ASMERR
IN_0:   INC     BYTE PTR [ASSEM1]
IN_1:   CALL    SCANP
        CMP     WORD PTR [SI],"D"+5800H ; "DX"
        JZ      DATRET
        MOV     CX,2
        CALL    GETHX
        JC      ERRV1
        AND     BYTE PTR [ASSEM1],11110111B
        MOV     AL,DL
        JMP     DISPX
;
;  out instruction
;
OUT_OPER:
        CALL    SCANB
        CMP     WORD PTR [SI],"D"+5800H ; "DX"
        JNZ     OUT_0
        INC     SI
        INC     SI
        JMP     SHORT OUT_1
OUT_0:  AND     BYTE PTR [ASSEM1],11110111B
        MOV     CX,2
        CALL    GETHX
        JC      ERRV1
        INC     BYTE PTR [ASSEM_CNT]
        MOV     BYTE PTR [ASSEM2],DL
OUT_1:  CALL    SCANP
        LODSW
        CMP     AX,"A"+4C00H            ; "AL"
        JZ      DATRET
        CMP     AX,"A"+5800H            ; "AX"
        JNZ     ERRV1
        INC     BYTE PTR [ASSEM1]
        JMP     DATRET

;
;  jump instruction
;
JMP_OPER:
        INC     BYTE PTR [TSTFLG]
;
;  call instruction
;
CALL_OPER:
        MOV     BYTE PTR [ASSEM1],11111111B
        MOV     BYTE PTR [MIDFLD],AL
        CALL    GETREGMEM
        CALL    BUILD3
        CMP     BYTE PTR [MEMFLG],0
        JNZ     CALLJ1
        CMP     BYTE PTR [REGMEM],-1
        JZ      CALLJ2
;
;  INDIRECT JUMPS OR CALLS
;
CALLJ1: CMP     BYTE PTR [AWORD],1
ERRZ4:  JZ      ERRV1
        CMP     BYTE PTR [AWORD],4
        JNZ     ASMEX4
        OR      BYTE PTR [DI+2],1000B
        JMP     SHORT ASMEX4
;
;   DIRECT JUMPS OR CALLS
;
CALLJ2: MOV     AX,[LOWNUM]
        MOV     DX,[HINUM]
        MOV     BL,[AWORD]
        CMP     BYTE PTR [NUMFLG],0
        JZ      ERRZ4

;  BL = NUMBER OF BYTES IN JUMP
;  DX = OFFSET
;  AX = SEGMENT

CALLJ3:
        MOV     BYTE PTR [DI],5
        MOV     [DI+2],AX
        MOV     [DI+4],DX

        MOV     AL,10011010B            ; SET UP INTER SEGMENT CALL
        CMP     BYTE PTR [TSTFLG],0
        JZ      CALLJ5
        MOV     AL,11101010B            ; FIX UP FOR JUMP
CALLJ5: MOV     BYTE PTR [DI+1],AL
        CMP     BL,4                    ; FAR SPECIFIED?
        JZ      ASMEX4
        OR      BL,BL
        JNZ     CALLJ6
        CMP     DX,WORD PTR [ASMADD+2]  ; DIFFERENT SEGMENT?
        JNZ     ASMEX4

CALLJ6: MOV     BYTE PTR [DI],3
        MOV     AL,11101000B            ; SET UP FOR INTRASEGMENT
        OR      AL,[TSTFLG]
        MOV     BYTE PTR [DI+1],AL

        MOV     AX,[LOWNUM]
        SUB     AX,WORD PTR [ASMADD]
        SUB     AX,3
        MOV     [DI+2],AX
        CMP     BYTE PTR [TSTFLG],0
        JZ      ASMEX4
        CMP     BL,2
        JZ      ASMEX4

        INC     AX
        MOV     CX,AX
        CBW
        CMP     AX,CX
        JNZ     ASMEX3
        MOV     BYTE PTR [DI+1],11101011B
        MOV     [DI+2],AX
        DEC     BYTE PTR [DI]
ASMEX4: JMP     ASSEM_EXIT
;
;  conditional jumps and loop instructions
;
DISP8_OPER:
        MOV     BP,WORD PTR [ASMADD+2]  ; GET DEFAULT DISPLACEMENT
        CALL    GET_ADDRESS
        SUB     DX,WORD PTR [ASMADD]
        DEC     DX
        DEC     DX
        CALL    CHKSIZ
        CMP     CL,1
        JNZ     ERRV2
DISPX:  INC     [ASSEM_CNT]
        MOV     BYTE PTR [ASSEM2],AL
ASMEX3: JMP     ASSEM_EXIT
;
;  lds, les, and lea instructions
;
L_OPER:
        CALL    SCANB
        LODSW
        MOV     CX,8
        MOV     DI,OFFSET DG:REG16
        CALL    CHKREG
        JZ      ERRV2                   ; CX = 0 MEANS NO REGISTER
        SHL     AL,1
        SHL     AL,1
        SHL     AL,1
        MOV     BYTE PTR [MIDFLD],AL
        CALL    SCANP
        CALL    GETREGMEM
        CMP     BYTE PTR [AWORD],0
        JNZ     ERRV2
        CALL    BUILD2
        JMP     SHORT ASEXV
;
;  dec and inc instructions
;
DCINC_OPER:
        MOV     BYTE PTR [ASSEM1],11111110B
        MOV     BYTE PTR [MIDFLD],AL
        CALL    GETREGMEM
        CALL    BUILDIT
        TEST    BYTE PTR [DI+1],1
        JZ      ASEXV
        MOV     AL,[DI+2]
        CMP     AL,11000000B
        JB      ASEXV
        AND     AL,1111B
        OR      AL,01000000B
        MOV     [DI+1],AL
        DEC     BYTE PTR [DI]
ASEXV:  JMP     ASSEM_EXIT

ERRV2:  JMP     ASMERR
;
; esc instruction
;
ESC_OPER:
        INC     BYTE PTR [AWORD]
        CALL    SCANB
        MOV     CX,2
        CALL    GETHX
        CMP     DX,64
        JAE     ERRV2
        CALL    SCANP
        MOV     AX,DX
        MOV     CL,3
        SHR     DX,CL
        OR      [ASSEM1],DL
        AND     AL,111B
        SHL     AL,CL
        JMP     GROUPE
;
; 8087 arithmetic instuctions
;

;
;  OPERANDS THAT ALLOW THE REVERSE BIT
;
FGROUPDS:
        CALL    SETMID
        CALL    GETREGMEM2
        CALL    BUILD3
        CMP     BYTE PTR [MODE],11000000B
        JNZ     FGROUP1
        MOV     AL,[DIRFLG]
        OR      AL,AL
        JZ      FEXIT
        OR      [DI+1],AL               ; IF D=1...
        XOR     BYTE PTR [DI+2],00001000B   ; ...REVERSE THE SENSE OF R
        JMP     SHORT FEXIT

;
;  Here when instruction could have memory or register operand
;
FGROUPX:
        CALL    SETMID                  ; THIS ENTRY POINT FOR 1 MEM OPER
        MOV     BYTE PTR [DIRFLG],0
        JMP     SHORT FGRP2
FGROUP:
        CALL    SETMID
FGRP2:
        CALL    GETREGMEM2
        CALL    BUILD3
        CMP     BYTE PTR [MODE],11000000B
        JNZ     FGROUP1
        MOV     AL,[DIRFLG]
        OR      [DI+1],AL
        JMP     SHORT FEXIT
FGROUP1:CALL    SETMF
FEXIT:  JMP     ASSEM_EXIT
;
; These 8087 instructions require a memory operand
;
FGROUPB:
        MOV     AH,5                    ; MUST BE TBYTE
        JMP     SHORT FGROUP3E
FGROUP3W:
        MOV     AH,2                    ; MUST BE WORD
        JMP     SHORT FGROUP3E
FGROUP3:
        MOV     AH,-1                   ; SIZE CANNOT BE SPECIFIED
FGROUP3E:
        MOV     [AWORD],AH
        CALL    SETMID
        CALL    GETREGMEM
        CMP     BYTE PTR [MODE],11000000B
        JZ      FGRPERR
FGRP:
        CALL    BUILD3
        JMP     FEXIT
;
; These 8087 instructions require a register operand
;
FGROUPP:                                ; 8087 POP OPERANDS
        MOV     BYTE PTR [AWORD],-1
        CALL    SETMID
        CALL    GETREGMEM2
        CMP     BYTE PTR [DIRFLG],0
        JNZ     FGRP
FGRPERR:JMP     ASMERR

FGROUPZ:                                ; ENTRY POINT WHERE ARG MUST BE MEM
        CALL    SETMID
        MOV     BYTE PTR [DIRFLG],0
        CALL    GETREGMEM
        CMP     BYTE PTR [MODE],11000000B
        JZ      FGRPERR
        CALL    BUILD3
        CALL    SETMF
        JMP     FEXIT
;
; not, neg, mul, imul, div, and idiv instructions
;
GROUP1:
        MOV     [ASSEM1],11110110B
GROUPE:
        MOV     BYTE PTR [MIDFLD],AL
        CALL    GETREGMEM
        CALL    BUILDIT
        JMP     FEXIT
;
;  shift and rotate instructions
;
ROTOP:
        MOV     [ASSEM1],11010000B
        MOV     BYTE PTR [MIDFLD],AL
        CALL    GETREGMEM
        CALL    BUILDIT
        CALL    SCANP
        CMP     BYTE PTR [SI],"1"
        JZ      ASMEXV1
        CMP     WORD PTR [SI],"LC"      ; CL
        JZ      ROTOP1
ROTERR: JMP     ASMERR
ROTOP1: OR      BYTE PTR [ASSEM1],10B
ASMEXV1:JMP     ASSEM_EXIT
;
;  xchg instruction
;
EX_OPER:
        INC     BYTE PTR [TSTFLG]
;
;   test instruction
;
TST_OPER:
        INC     BYTE PTR [TSTFLG]
        JMP     SHORT MOVOP
;
;    mov instruction
;
MOV_OPER:
        INC     BYTE PTR [MOVFLG]
MOVOP:  XOR     AX,AX
        JMP     SHORT GROUPM
;
;   add, adc, sub, sbb, cmp, and, or, xor instructions
;
GROUP2:
        MOV     BYTE PTR [ASSEM1],10000000B
GROUPM:
        MOV     BYTE PTR [MIDFLD],AL

        PUSH    AX
        CALL    GETREGMEM
        CALL    BUILD2
        CALL    SCANP                   ; POINT TO NEXT OPERAND
        MOV     AL,BYTE PTR [ASSEM_CNT]
        PUSH    AX
        CALL    GETREGMEM
        POP     AX
        MOV     BYTE PTR [DI],AL
        POP     AX
        MOV     BL,BYTE PTR [AWORD]
        OR      BL,BL
        JZ      ERRV5
        DEC     BL
        AND     BL,1
        OR      BYTE PTR [DI+1],BL

        CMP     BYTE PTR [MEMFLG],0
        JNZ     G21V
        CMP     BYTE PTR [NUMFLG],0     ; TEST FOR IMMEDIATE DATA
        JZ      G21V
        CMP     BYTE PTR [SEGFLG],0
        JNZ     ERRV5
        CMP     BYTE PTR [TSTFLG],2     ; XCHG?
        JNZ     IMMED1
ERRV5:  JMP     ASMERR
G21V:   JMP     GRP21
;
;  SECOND OPERAND WAS IMMEDIATE
;
IMMED1: MOV     AL,BYTE PTR [DI+2]
        CMP     BYTE PTR [MOVFLG],0
        JZ      NOTMOV1
        AND     AL,11000000B
        CMP     AL,11000000B
        JNZ     GRP23                   ; not to a register
                                        ; MOVE IMMEDIATE TO REGISTER
        MOV     AL,BYTE PTR [DI+1]
        AND     AL,1                    ; SET SIZE
        PUSHF
        SHL     AL,1
        SHL     AL,1
        SHL     AL,1
        OR      AL,BYTE PTR [DI+2]      ; SET REGISTER
        AND     AL,00001111B
        OR      AL,10110000B
        MOV     BYTE PTR [DI+1],AL
        MOV     AX,WORD PTR [LOWNUM]
        MOV     WORD PTR [DI+2],AX
        POPF
        JZ      EXVEC
        INC     BYTE PTR [DI]
EXVEC:  JMP     GRPEX

NOTMOV1:AND     AL,11000111B
        CMP     AL,11000000B
        JZ      IMMACC                  ; IMMEDIATE TO ACC

        CMP     BYTE PTR [TSTFLG],0
        JNZ     GRP23
        CMP     BYTE PTR [MIDFLD],1*8   ; OR?
        JZ      GRP23
        CMP     BYTE PTR [MIDFLD],4*8   ; AND?
        JZ      GRP23
        CMP     BYTE PTR [MIDFLD],6*8   ; XOR?
        JZ      GRP23
        TEST    BYTE PTR [DI+1],1       ; TEST IF BYTE OPCODE
        JZ      GRP23

        MOV     AX,[LOWNUM]
        MOV     BX,AX
        CBW
        CMP     AX,BX
        JNZ     GRP23                   ; SMALL ENOUGH?

        MOV     BL,[DI]
        DEC     BYTE PTR [DI]
        OR      BYTE PTR [DI+1],10B
        JMP     SHORT GRP23X

IMMACC: MOV     AL,BYTE PTR [DI+1]
        AND     AL,1
        CMP     BYTE PTR [TSTFLG],0
        JZ      NOTTST
        OR      AL,10101000B
        JMP     SHORT TEST1
NOTTST: OR      AL,BYTE PTR [MIDFLD]
        OR      AL,100B
TEST1:  MOV     BYTE PTR [DI+1],AL
        DEC     BYTE PTR [DI]

GRP23:  MOV     BL,BYTE PTR [DI]
GRP23X: XOR     BH,BH
        ADD     BX,DI
        INC     BX
        MOV     AX,WORD PTR [LOWNUM]
        MOV     WORD PTR [BX],AX
        INC     BYTE PTR [DI]
        TEST    BYTE PTR [DI+1],1
        JZ      GRPEX1
        INC     BYTE PTR [DI]
GRPEX1: JMP     GRPEX
;
;       SECOND OPERAND WAS MEMORY OR REGISTER
;
GRP21:
        CMP     BYTE PTR [SEGFLG],0
        JZ      GRP28                   ; FIRST OPERAND WAS A SEGMENT REG
        MOV     AL,BYTE PTR [REGMEM]
        TEST    AL,10000B
        JZ      NOTSEG1
ERRV3:  JMP     ASMERR
NOTSEG1:AND     AL,111B
        OR      BYTE PTR [DI+2],AL
        AND     BYTE PTR [DI+1],11111110B
        CMP     BYTE PTR [MEMFLG],0
        JNZ     G22V
        JMP     GRPEX

GRP28:  AND     BYTE PTR [DI+2],11000111B
        MOV     AL,BYTE PTR [DI+1]      ; GET FIRST OPCODE
        AND     AL,1B
        CMP     BYTE PTR [MOVFLG],0
        JZ      NOTMOV2
        OR      AL,10001000B
        JMP     SHORT MOV1
NOTMOV2:CMP     BYTE PTR [TSTFLG],0
        JZ      NOTTST2
        OR      AL,10000100B
        CMP     BYTE PTR [TSTFLG],2
        JNZ     NOTTST2
        OR      AL,10B
NOTTST2:OR      AL,BYTE PTR [MIDFLD]    ; MIDFLD IS ZERO FOR TST
MOV1:   MOV     BYTE PTR [DI+1],AL
        CMP     BYTE PTR [MEMFLG],0
G22V:   JNZ     GRP22
;
;       SECOND OPERAND WAS A REGISTER
;
        MOV     AL,BYTE PTR [REGMEM]
        TEST    AL,10000B               ; SEGMENT REGISTER?
        JZ      NOTSEG
        CMP     BYTE PTR [MOVFLG],0
        JZ      ERRV3
        MOV     BYTE PTR [DI+1],10001100B

NOTSEG: AND     AL,111B
        SHL     AL,1
        SHL     AL,1
        SHL     AL,1
        OR      BYTE PTR [DI+2],AL
;
; SPECIAL FORM OF THE EXCHANGE COMMAND
;
        CMP     BYTE PTR [TSTFLG],2
        JNZ     GRPEX
        TEST    BYTE PTR [DI+1],1
        JZ      GRPEX
        PUSH    AX
        MOV     AL,BYTE PTR [DI+2]
        AND     AL,11000000B
        CMP     AL,11000000B            ; MUST BE REGISTER TO REGISTER
        POP     AX
        JB      GRPEX
        OR      AL,AL
        JZ      SPECX
        MOV     AL,[DI+2]
        AND     AL,00000111B
        JNZ     GRPEX
        MOV     CL,3
        SHR     BYTE PTR [DI+2],CL
SPECX:  MOV     AL,[DI+2]
        AND     AL,00000111B
        OR      AL,10010000B
        MOV     BYTE PTR [DI+1],AL
        DEC     BYTE PTR [DI]
        JMP     SHORT GRPEX
;
;  SECOND OPERAND WAS A MEMORY REFERENCE
;
GRP22:  CMP     BYTE PTR [TSTFLG],0
        JNZ     TST2
        OR      BYTE PTR [DI+1],10B
TST2:   MOV     AL,BYTE PTR [DI+2]
        CMP     AL,11000000B            ; MUST BE A REGISTER
        JB      ASMERR
        CMP     BYTE PTR [SEGFLG],0
        JZ      GRP223
        AND     AL,00011000B
        JMP     SHORT GRP222
GRP223: AND     AL,111B
        SHL     AL,1
        SHL     AL,1
        SHL     AL,1
GRP222: OR      AL,BYTE PTR [MODE]
        OR      AL,BYTE PTR [REGMEM]
        MOV     BYTE PTR [DI+2],AL
        MOV     AX,WORD PTR [LOWNUM]
        MOV     WORD PTR [DI+3],AX
GRPSIZ: MOV     BYTE PTR [DI],2
        MOV     AL,BYTE PTR [DI+2]
        AND     AL,11000111B
        CMP     AL,00000110B
        JZ      GRP24
        AND     AL,11000000B
        CMP     AL,01000000B
        JZ      GRP25
        CMP     AL,10000000B
        JNZ     GRPEX
GRP24:  INC     BYTE PTR [DI]
GRP25:  INC     BYTE PTR [DI]

GRPEX:  CMP     BYTE PTR [MOVFLG],0
        JZ      ASSEM_EXIT
;
;       TEST FOR SPECIAL FORM OF MOV AX,[MEM] OR MOV [MEM],AX
;
        MOV     AL,[DI+1]               ; GET OP-CODE
        AND     AL,11111100B
        CMP     AL,10001000B
        JNZ     ASSEM_EXIT
        CMP     BYTE PTR [DI+2],00000110B   ; MEM TO AX OR AX TO MEM
        JNZ     ASSEM_EXIT
        MOV     AL,BYTE PTR [DI+1]
        AND     AL,11B
        XOR     AL,10B
        OR      AL,10100000B
        MOV     BYTE PTR [DI+1],AL
        DEC     BYTE PTR [DI]
        MOV     AX,[DI+3]
        MOV     WORD PTR [DI+2],AX

ASSEM_EXIT:
        CALL    STUFF_BYTES
        JMP     ASSEMLOOP

; Assem error. SI points to character in the input buffer
; which caused error. By subtracting from start of buffer,
; we will know how far to tab over to appear directly below
; it on the terminal. Then print "^ Error".

ASMERR:
        SUB     SI,OFFSET DG:(BYTEBUF-10)   ; How many char processed so far?
        MOV     CX,SI                   ; Parameter for TAB in CX
        CALL    TAB                     ; Directly below bad char
        MOV     SI,OFFSET DG:SYNERR     ; Error message
        CALL    PRINTMES
        JMP     ASSEMLOOP
;
;  assemble the different parts into an instruction
;
BUILDIT:
        MOV     AL,BYTE PTR [AWORD]
        OR      AL,AL
        JNZ     BUILD1
BLDERR: JMP     ASMERR

BUILD1: DEC     AL
        OR      BYTE PTR [DI+1],AL      ; SET THE SIZE

BUILD2: CMP     BYTE PTR [NUMFLG],0     ; TEST FOR IMMEDIATE DATA
        JZ      BUILD3
        CMP     BYTE PTR [MEMFLG],0
        JZ      BLDERR

BUILD3: MOV     AL,BYTE PTR [REGMEM]
        CMP     AL,-1
        JZ      BLD1
        TEST    AL,10000B               ; TEST IF SEGMENT REGISTER
        JZ      BLD1
        CMP     BYTE PTR [MOVFLG],0
        JZ      BLDERR
        MOV     WORD PTR [DI+1],10001110B
        INC     BYTE PTR [MOVFLG]
        INC     BYTE PTR [SEGFLG]
        AND     AL,00000011B
        SHL     AL,1
        SHL     AL,1
        SHL     AL,1
        OR      AL,BYTE PTR 11000000B
        MOV     BYTE PTR [DI+2],AL
        RET

BLD1:   AND     AL,00000111B
BLD4:   OR      AL,BYTE PTR [MODE]
        OR      AL,BYTE PTR [MIDFLD]
        MOV     BYTE PTR [DI+2],AL
        MOV     AX,WORD PTR [LOWNUM]
        MOV     WORD PTR [DI+3],AX
        RET

GETREGMEM:
        MOV     BYTE PTR [F8087],0
GETREGMEM2:
        CALL    SCANP
        XOR     AX,AX
        MOV     WORD PTR [LOWNUM],AX    ; OFFSET
        MOV     WORD PTR [DIFLG],AX     ; DIFLG+SIFLG
        MOV     WORD PTR [BXFLG],AX     ; BXFLG+BPFLG
        MOV     WORD PTR [NEGFLG],AX    ; NEGFLG+NUMFLG
        MOV     WORD PTR [MEMFLG],AX    ; MEMFLG+REGFLG
        DEC     AL
        CMP     BYTE PTR [F8087],0
        JZ      PUTREG
        MOV     AL,1                    ; DEFAULT 8087 REG IS 1
PUTREG: MOV     BYTE PTR [REGMEM],AL

GETLOOP:MOV     BYTE PTR [NEGFLG],0
GETLOOP1:
        MOV     AX,WORD PTR [SI]
        CMP     AL,','
        JZ      GOMODE
        CMP     AL,13
        JZ      GOMODE
        CMP     AL,';'
        JZ      GOMODE
        CMP     AL,9
        JZ      GETTB
        CMP     AL,' '
        JNZ     GOGET
GETTB:  INC     SI
        JMP     GETLOOP1
GOGET:  JMP     GETINFO
;
;  DETERMINE THE MODE BITS
;
GOMODE: MOV     DI,OFFSET DG:ASSEM_CNT
        MOV     BYTE PTR [MODE],11000000B
        MOV     BYTE PTR [ASSEM_CNT],2
        CMP     BYTE PTR [MEMFLG],0
        JNZ     GOMODE1
        MOV     AL,[NUMFLG]
        OR      AL,[REGFLG]
        JNZ     MORET
        OR      AL,[F8087]
        JZ      ERRET
        MOV     AL,[DI+1]
        OR      AL,[DIRFLG]
        CMP     AL,0DCH                 ; ARITHMETIC?
        JNZ     MORET
        MOV     BYTE PTR [DI+1],0DEH    ; ADD POP TO NULL ARG 8087
MORET:  RET
ERRET:  JMP     ASMERR

GOMODE1:MOV     BYTE PTR [MODE],0
        CMP     BYTE PTR [NUMFLG],0
        JZ      GOREGMEM

        MOV     BYTE PTR [DI],4
        MOV     AX,WORD PTR [DIFLG]
        OR      AX,WORD PTR [BXFLG]
        JNZ     GOMODE2
        MOV     BYTE PTR [REGMEM],00000110B
        RET

GOMODE2:MOV     BYTE PTR [MODE],10000000B
        CALL    CHKSIZ1
        CMP     CL,2
        JZ      GOREGMEM
        DEC     BYTE PTR [DI]
        MOV     BYTE PTR [MODE],01000000B
;
;  DETERMINE THE REG-MEM BITS
;
GOREGMEM:
        MOV     BX,WORD PTR [BXFLG]
        MOV     CX,WORD PTR [DIFLG]
        XOR     DX,DX
GOREG0:
        MOV     AL,BL                   ; BX
        ADD     AL,CH                   ; SI
        CMP     AL,2
        JZ      GOGO
        INC     DL
        MOV     AL,BL
        ADD     AL,CL
        CMP     AL,2
        JZ      GOGO
        INC     DL
        MOV     AL,BH
        ADD     AL,CH
        CMP     AL,2
        JZ      GOGO
        INC     DL
        MOV     AL,BH
        ADD     AL,CL
        CMP     AL,2
        JZ      GOGO
        INC     DL
        OR      CH,CH
        JNZ     GOGO
        INC     DL
        OR      CL,CL
        JNZ     GOGO
        INC     DL                      ; BP+DISP
        OR      BH,BH
        JZ      GOREG1
        CMP     BYTE PTR [MODE],0
        JNZ     GOGO
        MOV     BYTE PTR [MODE],01000000B
        INC     BYTE PTR [DI]
        DEC     DL
GOREG1: INC     DL                      ; BX+DISP
GOGO:   MOV     BYTE PTR [REGMEM],DL
        RET

GETINFO:CMP     AX,'EN'                 ; NEAR
        JNZ     GETREG3
GETREG0:MOV     DL,2
GETRG01:CALL    SETSIZ1
GETREG1:CALL    SCANS
        MOV     AX,WORD PTR [SI]
        CMP     AX,"TP"                 ; PTR
        JZ      GETREG1
        JMP     GETLOOP

GETREG3:MOV     CX,5
        MOV     DI,OFFSET DG:SIZ8
        CALL    CHKREG                  ; LOOK FOR BYTE, WORD, DWORD, ETC.
        JZ      GETREG41
        INC     AL
        MOV     DL,AL
        JMP     GETRG01

GETREG41:
        MOV     AX,[SI]
        CMP     BYTE PTR [F8087],0
        JZ      GETREG5
        CMP     AX,"TS"                 ; 8087 STACK OPERAND
        JNZ     GETREG5
        CMP     BYTE PTR [SI+2],","
        JNZ     GETREG5
        MOV     BYTE PTR [DIRFLG],0
        ADD     SI,3
        JMP     GETLOOP

GETREG5:CMP     AX,"HS"                 ; SHORT
        JZ      GETREG1

        CMP     AX,"AF"                 ; FAR
        JNZ     GETRG51
        CMP     BYTE PTR [SI+2],"R"
        JNZ     GETRG51
        ADD     SI,3
        MOV     DL,4
        JMP     GETRG01

GETRG51:CMP     AL,'['
        JNZ     GETREG7
GETREG6:INC     BYTE PTR [MEMFLG]
        INC     SI
        JMP     GETLOOP

GETREG7:CMP     AL,']'
        JZ      GETREG6
        CMP     AL,'.'
        JZ      GETREG6
        CMP     AL,'+'
        JZ      GETREG6
        CMP     AL,'-'
        JNZ     GETREG8
        INC     BYTE PTR [NEGFLG]
        INC     SI
        JMP     GETLOOP1

GETREG8:                                ; LOOK FOR A REGISTER
        CMP     BYTE PTR [F8087],0
        JZ      GETREGREG
        CMP     AX,"TS"
        JNZ     GETREGREG
        CMP     BYTE PTR [SI+2],"("
        JNZ     GETREGREG
        CMP     BYTE PTR [SI+4],")"
        JNZ     ASMPOP
        MOV     AL,[SI+3]
        SUB     AL,"0"
        JB      ASMPOP
        CMP     AL,7
        JA      ASMPOP
        MOV     [REGMEM],AL
        INC     BYTE PTR [REGFLG]
        ADD     SI,5
        CMP     WORD PTR [SI],"S,"
        JNZ     ZLOOP
        CMP     BYTE PTR [SI+2],"T"
        JNZ     ZLOOP
        ADD     SI,3
ZLOOP:  JMP     GETLOOP

GETREGREG:
        MOV     CX,20
        MOV     DI,OFFSET DG:REG8
        CALL    CHKREG
        JZ      GETREG12                ; CX = 0 MEANS NO REGISTER
        MOV     BYTE PTR [REGMEM],AL
        INC     BYTE PTR [REGFLG]       ; TELL EVERYONE WE FOUND A REG
        CMP     BYTE PTR [MEMFLG],0
        JNZ     NOSIZE
        CALL    SETSIZ
INCSI2: ADD     SI,2
        JMP     GETLOOP

NOSIZE: CMP     AL,11                   ; BX REGISTER?
        JNZ     GETREG9
        CMP     WORD PTR [BXFLG],0
        JZ      GETOK
ASMPOP: JMP     ASMERR

GETOK:  INC     BYTE PTR [BXFLG]
        JMP     INCSI2
GETREG9:
        CMP     AL,13                   ; BP REGISTER?
        JNZ     GETREG10
        CMP     WORD PTR [BXFLG],0
        JNZ     ASMPOP
        INC     BYTE PTR [BPFLG]
        JMP     INCSI2
GETREG10:
        CMP     AL,14                   ; SI REGISTER?
        JNZ     GETREG11
        CMP     WORD PTR [DIFLG],0
        JNZ     ASMPOP
        INC     BYTE PTR [SIFLG]
        JMP     INCSI2
GETREG11:
        CMP     AL,15                   ; DI REGISTER?
        JNZ     ASMPOP                  ; *** error
        CMP     WORD PTR [DIFLG],0
        JNZ     ASMPOP
        INC     BYTE PTR [DIFLG]
        JMP     INCSI2

GETREG12:                               ; BETTER BE A NUMBER!
        MOV     BP,WORD PTR [ASMADD+2]
        CMP     BYTE PTR [MEMFLG],0
        JZ      GTRG121
GTRG119:MOV     CX,4
GTRG120:CALL    GETHX
        JMP     SHORT GTRG122
GTRG121:MOV     CX,2
        CMP     BYTE PTR [AWORD],1
        JZ      GTRG120
        CMP     BYTE PTR [AWORD],CL
        JZ      GTRG119
        CALL    GET_ADDRESS
GTRG122:JC      ASMPOP
        MOV     [HINUM],AX
        CMP     BYTE PTR [NEGFLG],0
        JZ      GETREG13
        NEG     DX
GETREG13:
        ADD     WORD PTR [LOWNUM],DX
        INC     BYTE PTR [NUMFLG]
GETLOOPV:
        JMP     GETLOOP

CHKREG: PUSH    CX
        INC     CX
        REPNZ   SCASW
        POP     AX
        SUB     AX,CX
        OR      CX,CX
        RET

STUFF_BYTES:
        PUSH    SI
        LES     DI,DWORD PTR ASMADD
        MOV     SI,OFFSET DG:ASSEM_CNT
        XOR     AX,AX
        LODSB
        MOV     CX,AX
        JCXZ    STUFFRET
        REP     MOVSB
        MOV     WORD PTR [ASMADD],DI
STUFFRET:
        POP     SI
        RET

SETSIZ:
        MOV     DL,1
        TEST    AL,11000B               ; 16 BIT OR SEGMENT REGISTER?
        JZ      SETSIZ1
        INC     DL
SETSIZ1:
        CMP     BYTE PTR [AWORD],0
        JZ      SETSIZ2
        CMP     BYTE PTR [AWORD],DL
        JZ      SETSIZ2
SETERR: POP     DX
        JMP     ASMPOP
SETSIZ2:MOV     BYTE PTR [AWORD],DL
        RET
;
;  DETERMINE IF NUMBER IN AX:DX IS 8 BITS, 16 BITS, OR 32 BITS
;
CHKSIZ: MOV     CL,4
        CMP     AX,BP
        JNZ     RETCHK
CHKSIZ1:MOV     CL,2
        MOV     AX,DX
        CBW
        CMP     AX,DX
        JNZ     RETCHK
        DEC     CL
RETCHK: RET
;
;  get first character after first space
;
SCANS:  CMP     BYTE PTR [SI],13
        JZ      RETCHK
        CMP     BYTE PTR [SI],"["
        JZ      RETCHK
        LODSB
        CMP     AL," "
        JZ      SCANBV
        CMP     AL,9
        JNZ     SCANS
SCANBV: JMP     SCANB
;
; Set up for 8087 op-codes
;
SETMID:
        MOV     BYTE PTR [ASSEM1],0D8H
        MOV     AH,AL
        AND     AL,111B                 ; SET MIDDLE BITS OF SECOND BYTE
        SHL     AL,1
        SHL     AL,1
        SHL     AL,1
        MOV     [MIDFLD],AL
        MOV     AL,AH                   ; SET LOWER BITS OF FIRST BYTE
        SHR     AL,1
        SHR     AL,1
        SHR     AL,1
        OR      [ASSEM1],AL
        MOV     BYTE PTR [F8087],1      ; INDICATE 8087 OPERAND
        MOV     BYTE PTR [DIRFLG],100B
        RET
;
; Set MF bits for 8087 op-codes
;
SETMF:  MOV     AL,[AWORD]
        TEST    BYTE PTR [DI+1],10B
        JNZ     SETMFI
        AND     BYTE PTR [DI+1],11111001B   ; CLEAR MF BITS
        CMP     AL,3                    ; DWORD?
        JZ      SETMFRET
        CMP     AL,4                    ; QWORD?
        JZ      SETMFRET2
        TEST    BYTE PTR [DI+1],1
        JZ      SETMFERR
        CMP     AL,5                    ; TBYTE?
        JZ      SETMFRET3
        JMP     SHORT SETMFERR

SETMFI: CMP     AL,3                    ; DWORD?
        JZ      SETMFRET
        CMP     AL,2                    ; WORD?
        JZ      SETMFRET2
        TEST    BYTE PTR [DI+1],1
        JZ      SETMFERR
        CMP     AL,4                    ; QWORD?
        JNZ     SETMFERR
        OR      BYTE PTR [DI+1],111B
SETMFRET3:
        OR      BYTE PTR [DI+1],011B
        OR      BYTE PTR [DI+2],101000B
        JMP     SHORT SETMFRET
SETMFRET2:
        OR      BYTE PTR [DI+1],100B
SETMFRET:
        RET

SETMFERR:
        JMP     ASMPOP


DW_OPER:
        MOV     BP,1
        JMP     SHORT DBEN

DB_OPER:
        XOR     BP,BP
DBEN:   MOV     DI,OFFSET DG:ASSEM_CNT
        DEC     BYTE PTR [DI]
        INC     DI
DB0:    XOR     BL,BL
        CALL    SCANP
        JNZ     DB1
DBEX:   JMP     ASSEM_EXIT
DB1:    OR      BL,BL
        JNZ     DB3
        MOV     BH,BYTE PTR [SI]
        CMP     BH,"'"
        JZ      DB2
        CMP     BH,'"'
        JNZ     DB4
DB2:    INC     SI
        INC     BL
DB3:    LODSB
        CMP     AL,13
        JZ      DBEX
        CMP     AL,BH
        JZ      DB0
        STOSB
        INC     BYTE PTR [ASSEM_CNT]
        JMP     DB3
DB4:    MOV     CX,2
        CMP     BP,0
        JZ      DB41
        MOV     CL,4
DB41:   PUSH    BX
        CALL    GETHX
        POP     BX
        JNC     DB5
        JMP     ASMERR
DB5:    MOV     AX,DX
        CMP     BP,0
        JZ      DB6
        STOSW
        INC     BYTE PTR [ASSEM_CNT]
        JMP     SHORT DB7
DB6:    STOSB
DB7:    INC     BYTE PTR [ASSEM_CNT]
        JMP     DB0

CODE    ENDS
        END ASSEM