v4.0/src/CMD/DEBUG/DEBASM.ASM

   1         PAGE    80,132 ;\ f
   2         TITLE   DEBASM.ASM
   3 ; CODE FOR THE ASSEMBLE COMMAND IN THE DEBUGGER
   4
   5         IF1
   6             %OUT COMPONENT=DEBUG, MODULE=DEBASM
   7         ENDIF
   8 .XLIST
   9 .XCREF
  10         INCLUDE DOSSYM.INC
  11         INCLUDE DEBEQU.ASM
  12 .CREF
  13 .LIST
  14
  15
  16 CODE    SEGMENT PUBLIC BYTE
  17 CODE    ENDS
  18
  19 CONST   SEGMENT PUBLIC BYTE
  20
  21         EXTRN   DBMN:BYTE,CSSAVE:WORD,REG8:BYTE,REG16:BYTE,SIZ8:BYTE
  22         EXTRN   SYNERR_PTR:BYTE,OPTAB:BYTE,MAXOP:ABS
  23
  24 CONST   ENDS
  25
  26 CSTACK  SEGMENT STACK
  27 CSTACK  ENDS
  28
  29 DATA    SEGMENT PUBLIC BYTE
  30
  31         EXTRN   HINUM:WORD,LOWNUM:WORD,ASSEM_CNT:BYTE
  32         EXTRN   ASSEM1:BYTE,ASSEM2:BYTE,ASSEM3:BYTE,ASSEM4:BYTE,ASSEM5:BYTE
  33         EXTRN   ASSEM6:BYTE,OPBUF:BYTE,OPCODE:WORD,REGMEM:BYTE,INDEX:WORD
  34         EXTRN   ASMADD:BYTE,ASMSP:WORD,MOVFLG:BYTE,SEGFLG:BYTE,TSTFLG:BYTE
  35         EXTRN   NUMFLG:BYTE,DIRFLG:BYTE,BYTEBUF:BYTE,F8087:BYTE,DIFLG:BYTE
  36         EXTRN   SIFLG:BYTE,BXFLG:BYTE,BPFLG:BYTE,NEGFLG:BYTE,MEMFLG:BYTE
  37         EXTRN   REGFLG:BYTE,AWORD:BYTE,MIDFLD:BYTE,MODE:BYTE
  38         EXTRN   ARG_BUF:BYTE,HEX_PTR:BYTE
  39
  40 DATA    ENDS
  41
  42 DG      GROUP   CODE,CONST,CSTACK,DATA
  43
  44 CODE    SEGMENT PUBLIC BYTE
  45 ASSUME  CS:DG,DS:DG,ES:DG,SS:DG
  46
  47         PUBLIC  ASSEM
  48         PUBLIC  DB_OPER,DW_OPER,ASSEMLOOP,GROUP2,AA_OPER,DCINC_OPER
  49         PUBLIC  GROUP1,ESC_OPER,FGROUPP,FGROUPX,FDE_OPER,FGROUPZ
  50         PUBLIC  FD9_OPER,FGROUP,FDB_OPER,FGROUPB,FGROUP3,FGROUP3W
  51         PUBLIC  FGROUPDS,INT_OPER,IN_OPER,DISP8_OPER,JMP_OPER,NO_OPER
  52         PUBLIC  OUT_OPER,L_OPER,MOV_OPER,POP_OPER,PUSH_OPER,ROTOP
  53         PUBLIC  TST_OPER,EX_OPER,GET_DATA16,CALL_OPER, DOORG
  54
  55         EXTRN   INBUF:NEAR,SCANB:NEAR,SCANP:NEAR,GETHX:NEAR,GET_ADDRESS:NEAR
  56         EXTRN   DEFAULT:NEAR,OUTDI:NEAR,BLANK:NEAR,TAB:NEAR
  57         EXTRN   STD_PRINTF:NEAR,PRINTF_CRLF:NEAR
  58
  59 ;       Line by line assembler
  60
  61 MASKMOD EQU     11000000B
  62 SHMOD   EQU     6
  63 MASKREG EQU     00111000B
  64 SHREG   EQU     3
  65 MASKRM  EQU     00000111B
  66 SHRM    EQU     0
  67
  68 ASSEM:
  69         MOV     BP,[CSSAVE]             ; Default code segment
  70         MOV     DI,OFFSET DG:ASMADD     ; Default address
  71         CALL    DEFAULT
  72         MOV     WORD PTR [ASMADD],DX    ; Displacement of disassembly
  73         MOV     WORD PTR [ASMADD+2],AX  ; Segment
  74         MOV     [ASMSP],SP              ; Save sp in case of error
  75
  76 ASSEMLOOP:
  77         MOV     SP,[ASMSP]              ; Restore sp in case of error
  78         LES     DI,DWORD PTR ASMADD     ; GET PC
  79         CALL    OUTDI                   ; OUTPUT ADDRESS
  80         PUSH    CS
  81         POP     ES
  82         PUSH    DI
  83         MOV     DI,OFFSET DG:ARG_BUF
  84 ; No spacing is needed.  The format string already has one.
  85 ;       CALL    BLANK                   ; SKIP A SPACE
  86         XOR     AL,AL
  87         STOSB
  88         MOV     DX,OFFSET DG:HEX_PTR
  89         CALL    STD_PRINTF
  90         POP     DI
  91         CALL    INBUF                   ; GET A BUFFER
  92         CALL    SCANB
  93         JNZ     OPLOOK
  94         RET                             ; if empty just return
  95
  96 ;  At this point ds:si points to the opcode mnemonic...
  97 OPLOOK:
  98         XOR     CX,CX                   ; OP-CODE COUNT = 0
  99         MOV     DI,OFFSET DG:DBMN
 100 OPSCAN:
 101         XOR     BX,BX
 102 OPLOOP:
 103         MOV     AL,[DI+BX]
 104         CMP     AL,[SI+BX]
 105         JZ      OPMATCH
 106         INC     CX                      ; INCREMENT OP-CODE COUNT
 107         CMP     CX,MAXOP                ; CHECK FOR END OF LIST
 108         JB      OP1
 109         JMP     ASMERR
 110 OP1:
 111         INC     DI                      ; SCAN FOR NEXT OP-CODE...
 112         CMP     BYTE PTR [DI-1],0
 113         JNZ     OP1
 114         JMP     OPSCAN
 115
 116 OPMATCH:
 117         INC     BX                      ; COMPARE NEXT CHAR
 118         CMP     BYTE PTR [DI+BX],0      ; ARE WE DONE?
 119         JNZ     OPLOOP                  ; ..IF NOT KEEP COMPARING
 120         XCHG    BX,CX
 121         MOV     AX,BX
 122         SHL     AX,1
 123         ADD     AX,BX
 124         ADD     AX,OFFSET DG:OPTAB
 125         MOV     BX,AX
 126
 127 ; CX = COUNT OF CHARS IN OPCODE
 128 ; BX = POINTER INTO OPCODE TABLE
 129
 130         XOR     AX,AX
 131         MOV     BYTE PTR [AWORD],AL
 132         MOV     WORD PTR [MOVFLG],AX    ; MOVFLG + TSTFLG
 133         MOV     BYTE PTR [SEGFLG],AL    ; ZERO SEGMENT REGISTER FLAG
 134         MOV     AH,00001010B            ; SET UP FOR AA_OPER
 135         MOV     AL,BYTE PTR [BX]
 136         MOV     WORD PTR [ASSEM1],AX
 137         MOV     BYTE PTR [ASSEM_CNT],1
 138
 139         ADD     SI,CX                   ; SI POINTS TO OPERAND
 140         JMP     WORD PTR [BX+1]
 141
 142 ; 8087 INSTRUCTIONS WITH NO OPERANDS
 143
 144 FDE_OPER:
 145         MOV     AH,0DEH
 146         JMP     SHORT FDX_OPER
 147 FDB_OPER:
 148         MOV     AH,0DBH
 149         JMP     SHORT FDX_OPER
 150 FD9_OPER:
 151         MOV     AH,0D9H
 152 FDX_OPER:
 153         XCHG    AL,AH
 154         MOV     WORD PTR [ASSEM1],AX
 155
 156 ;  AAD AND AAM INSTRUCIONS
 157
 158 AA_OPER:
 159         INC     BYTE PTR [ASSEM_CNT]
 160
 161 ;  INSTRUCTIONS WITH NO OPERANDS
 162
 163 NO_OPER:
 164         CALL    STUFF_BYTES
 165         CALL    SCANP
 166         PUSH    CS
 167         POP     ES
 168         JNZ     OPLOOK
 169         JMP     ASSEMLOOP
 170
 171 ;  PUSH INSTRUCTION
 172
 173 PUSH_OPER:
 174         MOV     AH,11111111B
 175         JMP     SHORT POP1
 176
 177 ;  POP INSTRUCTION
 178
 179 POP_OPER:
 180         MOV     AH,10001111B
 181 POP1:
 182         MOV     [ASSEM1],AH
 183         MOV     [MIDFLD],AL
 184         INC     BYTE PTR [MOVFLG]       ; ALLOW SEGMENT REGISTERS
 185         MOV     BYTE PTR [AWORD],2      ; MUST BE 16 BITS
 186         CALL    GETREGMEM
 187         CALL    BUILDIT
 188         MOV     AL,[DI+2]
 189         CMP     AL,11000000B
 190         JB      DATRET
 191         MOV     BYTE PTR [DI],1
 192         CMP     BYTE PTR [MOVFLG],2
 193         JNZ     POP2
 194         AND     AL,00011000B
 195         OR      AL,00000110B
 196         CMP     BYTE PTR [MIDFLD],0
 197         JNZ     POP3
 198         OR      AL,00000001B
 199         JMP     SHORT POP3
 200
 201 POP2:
 202         AND     AL,MASKRM
 203         OR      AL,01010000B
 204         CMP     BYTE PTR [MIDFLD],0
 205         JNZ     POP3
 206         OR      AL,01011000B
 207 POP3:
 208         MOV     BYTE PTR [DI+1],AL
 209         JMP     ASSEM_EXIT
 210
 211 ; RET AND RETF INSTRUCTIONS
 212
 213 GET_DATA16:
 214         CALL    SCANB
 215         MOV     CX,4
 216         CALL    GETHX
 217         JC      DATRET
 218         DEC     BYTE PTR [ASSEM1]       ; CHANGE OP-CODE
 219         ADD     BYTE PTR [ASSEM_CNT],2  ; UPDATE LENGTH
 220         MOV     WORD PTR [ASSEM2],DX    ; SAVE OFFSET
 221 DATRET:
 222         JMP     ASSEM_EXIT
 223
 224
 225 ;  INT INSTRUCTION
 226
 227 INT_OPER:
 228         CALL    SCANB
 229         MOV     CX,2
 230         CALL    GETHX
 231         JC      ERRV1
 232         MOV     AL,DL
 233         CMP     AL,3
 234         JZ      DATRET
 235         INC     BYTE PTR [ASSEM1]
 236         JMP     DISPX
 237
 238 ;  IN INSTRUCTION
 239
 240 IN_OPER:
 241         CALL    SCANB
 242         LODSW
 243         CMP     AX,'A'+4C00H            ; "AL"
 244         JZ      IN_1
 245         CMP     AX,'A'+5800H            ; "AX"
 246         JZ      IN_0
 247 ERRV1:
 248         JMP     ASMERR
 249 IN_0:
 250         INC     BYTE PTR [ASSEM1]
 251 IN_1:
 252         CALL    SCANP
 253         CMP     WORD PTR [SI],'D'+5800H ; "DX"
 254         JZ      DATRET
 255         MOV     CX,2
 256         CALL    GETHX
 257         JC      ERRV1
 258         AND     BYTE PTR [ASSEM1],11110111B
 259         MOV     AL,DL
 260         JMP     DISPX
 261
 262 ;  OUT INSTRUCTION
 263
 264 OUT_OPER:
 265         CALL    SCANB
 266         CMP     WORD PTR [SI],'D'+5800H ; "DX"
 267         JNZ     OUT_0
 268         INC     SI
 269         INC     SI
 270         JMP     SHORT OUT_1
 271 OUT_0:
 272         AND     BYTE PTR [ASSEM1],11110111B
 273         MOV     CX,2
 274         CALL    GETHX
 275         JC      ERRV1
 276         INC     BYTE PTR [ASSEM_CNT]
 277         MOV     BYTE PTR [ASSEM2],DL
 278 OUT_1:
 279         CALL    SCANP
 280         LODSW
 281         CMP     AX,'A'+4C00H            ; "AL"
 282         JZ      DATRET
 283         CMP     AX,'A'+5800H            ; "AX"
 284         JNZ     ERRV1
 285         INC     BYTE PTR [ASSEM1]
 286         JMP     DATRET
 287
 288
 289 ;  JUMP INSTRUCTION
 290
 291 JMP_OPER:
 292         INC     BYTE PTR [TSTFLG]
 293
 294 ;  CALL INSTRUCTION
 295
 296 CALL_OPER:
 297         MOV     BYTE PTR [ASSEM1],11111111B
 298         MOV     BYTE PTR [MIDFLD],AL
 299         CALL    GETREGMEM
 300         CALL    BUILD3
 301         CMP     BYTE PTR [MEMFLG],0
 302         JNZ     CALLJ1
 303         CMP     BYTE PTR [REGMEM],-1
 304         JZ      CALLJ2
 305
 306 ;  INDIRECT JUMPS OR CALLS
 307
 308 CALLJ1:
 309         CMP     BYTE PTR [AWORD],1
 310 ERRZ4:
 311         JZ      ERRV1
 312         CMP     BYTE PTR [AWORD],4
 313         JNZ     ASMEX4
 314         OR      BYTE PTR [DI+2],1000B
 315         JMP     SHORT ASMEX4
 316
 317 ;   DIRECT JUMPS OR CALLS
 318
 319 CALLJ2:
 320         MOV     AX,[LOWNUM]
 321         MOV     DX,[HINUM]
 322         MOV     BL,[AWORD]
 323         CMP     BYTE PTR [NUMFLG],0
 324         JZ      ERRZ4
 325
 326 ;  BL = NUMBER OF BYTES IN JUMP
 327 ;  DX = OFFSET
 328 ;  AX = SEGMENT
 329
 330 CALLJ3:
 331         MOV     BYTE PTR [DI],5
 332         MOV     [DI+2],AX
 333         MOV     [DI+4],DX
 334
 335         MOV     AL,10011010B            ; SET UP INTER SEGMENT CALL
 336         CMP     BYTE PTR [TSTFLG],0
 337         JZ      CALLJ5
 338         MOV     AL,11101010B            ; FIX UP FOR JUMP
 339 CALLJ5:
 340         MOV     BYTE PTR [DI+1],AL
 341         CMP     BL,4                    ; FAR SPECIFIED?
 342         JZ      ASMEX4
 343         OR      BL,BL
 344         JNZ     CALLJ6
 345         CMP     DX,WORD PTR [ASMADD+2]  ; DIFFERENT SEGMENT?
 346         JNZ     ASMEX4
 347
 348 CALLJ6:
 349         MOV     BYTE PTR [DI],3
 350         MOV     AL,11101000B            ; SET UP FOR INTRASEGMENT
 351         OR      AL,[TSTFLG]
 352         MOV     BYTE PTR [DI+1],AL
 353
 354         MOV     AX,[LOWNUM]
 355         SUB     AX,WORD PTR [ASMADD]
 356         SUB     AX,3
 357         MOV     [DI+2],AX
 358         CMP     BYTE PTR [TSTFLG],0
 359         JZ      ASMEX4
 360         CMP     BL,2
 361         JZ      ASMEX4
 362
 363         INC     AX
 364         MOV     CX,AX
 365         CBW
 366         CMP     AX,CX
 367         JNZ     ASMEX3
 368         MOV     BYTE PTR [DI+1],11101011B
 369         MOV     [DI+2],AX
 370         DEC     BYTE PTR [DI]
 371 ASMEX4:
 372         JMP     ASSEM_EXIT
 373
 374 ;  CONDITIONAL JUMPS AND LOOP INSTRUCTIONS
 375
 376 DISP8_OPER:
 377         MOV     BP,WORD PTR [ASMADD+2]  ; GET DEFAULT DISPLACEMENT
 378         CALL    GET_ADDRESS
 379         SUB     DX,WORD PTR [ASMADD]
 380         DEC     DX
 381         DEC     DX
 382         CALL    CHKSIZ
 383         CMP     CL,1
 384         JNZ     ERRV2
 385 DISPX:
 386         INC     [ASSEM_CNT]
 387         MOV     BYTE PTR [ASSEM2],AL
 388 ASMEX3:
 389         JMP     ASSEM_EXIT
 390
 391 ;  LDS, LES, AND LEA INSTRUCTIONS
 392
 393 L_OPER:
 394         CALL    SCANB
 395         LODSW
 396         MOV     CX,8
 397         MOV     DI,OFFSET DG:REG16
 398         CALL    CHKREG
 399         JZ      ERRV2                   ; CX = 0 MEANS NO REGISTER
 400         SHL     AL,1
 401         SHL     AL,1
 402         SHL     AL,1
 403         MOV     BYTE PTR [MIDFLD],AL
 404         CALL    SCANP
 405         CALL    GETREGMEM
 406         CMP     BYTE PTR [AWORD],0
 407         JNZ     ERRV2
 408         CALL    BUILD2
 409         JMP     SHORT ASEXV
 410
 411 ;  DEC AND INC INSTRUCTIONS
 412
 413 DCINC_OPER:
 414         MOV     BYTE PTR [ASSEM1],11111110B
 415         MOV     BYTE PTR [MIDFLD],AL
 416         CALL    GETREGMEM
 417         CALL    BUILDIT
 418         TEST    BYTE PTR [DI+1],1
 419         JZ      ASEXV
 420         MOV     AL,[DI+2]
 421         CMP     AL,MASKMOD
 422         JB      ASEXV
 423         AND     AL,1111B
 424         OR      AL,01000000B
 425         MOV     [DI+1],AL
 426         DEC     BYTE PTR [DI]
 427 ASEXV:
 428         JMP     ASSEM_EXIT
 429
 430 ERRV2:
 431         JMP     ASMERR
 432
 433 ; ESC INSTRUCTION
 434
 435 ESC_OPER:
 436         INC     BYTE PTR [AWORD]
 437         CALL    SCANB
 438         MOV     CX,2
 439         CALL    GETHX
 440         CMP     DX,64
 441         JAE     ERRV2
 442         CALL    SCANP
 443         MOV     AX,DX
 444         MOV     CL,3
 445         SHR     DX,CL
 446         OR      [ASSEM1],DL
 447         AND     AL,111B
 448         SHL     AL,CL
 449         JMP     GROUPE
 450
 451 ; 8087 ARITHMETIC INSTUCTIONS
 452
 453 ;  OPERANDS THAT ALLOW THE REVERSE BIT
 454
 455 FGROUPDS:
 456         CALL    SETMID
 457         CALL    GETREGMEM2
 458         CALL    BUILD3
 459         CMP     BYTE PTR [MODE],11000000B
 460         JNZ     FGROUP1
 461         MOV     AL,[DIRFLG]
 462         OR      AL,AL
 463         JZ      FEXIT
 464         OR      [DI+1],AL               ; IF D=1...
 465         XOR     BYTE PTR [DI+2],00001000B ; ...REVERSE THE SENSE OF R
 466         JMP     SHORT FEXIT
 467
 468 ;  HERE WHEN INSTRUCTION COULD HAVE MEMORY OR REGISTER OPERAND
 469
 470 FGROUPX:
 471         CALL    SETMID                  ; THIS ENTRY POINT FOR 1 MEM OPER
 472         MOV     BYTE PTR [DIRFLG],0
 473         JMP     SHORT FGRP2
 474 FGROUP:
 475         CALL    SETMID
 476 FGRP2:
 477         CALL    GETREGMEM2
 478         CALL    BUILD3
 479         CMP     BYTE PTR [MODE],11000000B
 480         JNZ     FGROUP1
 481         MOV     AL,[DIRFLG]
 482         OR      [DI+1],AL
 483         JMP     SHORT FEXIT
 484 FGROUP1:
 485         CALL    SETMF
 486 FEXIT:
 487         JMP     ASSEM_EXIT
 488
 489 ; THESE 8087 INSTRUCTIONS REQUIRE A MEMORY OPERAND
 490 FGROUPB:
 491         MOV     AH,5                    ; MUST BE TBYTE
 492         JMP     SHORT FGROUP3E
 493 FGROUP3W:
 494         MOV     AH,2                    ; MUST BE WORD
 495         JMP     SHORT FGROUP3E
 496 FGROUP3:
 497         MOV     AH,-1                   ; SIZE CANNOT BE SPECIFIED
 498 FGROUP3E:
 499         MOV     [AWORD],AH
 500         CALL    SETMID
 501         CALL    GETREGMEM
 502         CMP     BYTE PTR [MODE],11000000B
 503         JZ      FGRPERR
 504 FGRP:
 505         CALL    BUILD3
 506         JMP     FEXIT
 507
 508 ; THESE 8087 INSTRUCTIONS REQUIRE A REGISTER OPERAND
 509 FGROUPP:                                ; 8087 POP OPERANDS
 510         MOV     BYTE PTR [AWORD],-1
 511         CALL    SETMID
 512         CALL    GETREGMEM2
 513         CMP     BYTE PTR [DIRFLG],0
 514         JNZ     FGRP
 515 FGRPERR:
 516         JMP     ASMERR
 517
 518 FGROUPZ:                                ; ENTRY POINT WHERE ARG MUST BE MEM
 519         CALL    SETMID
 520         MOV     BYTE PTR [DIRFLG],0
 521         CALL    GETREGMEM
 522         CMP     BYTE PTR [MODE],11000000B
 523         JZ      FGRPERR
 524         CALL    BUILD3
 525         CALL    SETMF
 526         JMP     FEXIT
 527
 528 ; NOT, NEG, MUL, IMUL, DIV, AND IDIV INSTRUCTIONS
 529
 530 GROUP1:
 531         MOV     [ASSEM1],11110110B
 532 GROUPE:
 533         MOV     BYTE PTR [MIDFLD],AL
 534         CALL    GETREGMEM
 535         CALL    BUILDIT
 536         JMP     FEXIT
 537
 538 ;  SHIFT AND ROTATE INSTRUCTIONS
 539
 540 ROTOP:
 541         MOV     [ASSEM1],11010000B
 542         MOV     BYTE PTR [MIDFLD],AL
 543         CALL    GETREGMEM
 544         CALL    BUILDIT
 545         CALL    SCANP
 546         CMP     BYTE PTR [SI],'1'
 547         JZ      ASMEXV1
 548         CMP     WORD PTR [SI],"LC"      ; CL
 549         JZ      ROTOP1
 550 ROTERR:
 551         JMP     ASMERR
 552 ROTOP1:
 553         OR      BYTE PTR [ASSEM1],10B
 554 ASMEXV1:
 555         JMP     ASSEM_EXIT
 556
 557 ;  XCHG INSTRUCTION
 558
 559 EX_OPER:
 560         INC     BYTE PTR [TSTFLG]
 561
 562 ;   TEST INSTRUCTION
 563
 564 TST_OPER:
 565         INC     BYTE PTR [TSTFLG]
 566         JMP     SHORT MOVOP
 567
 568 ;    MOV INSTRUCTION
 569
 570 MOV_OPER:
 571         INC     BYTE PTR [MOVFLG]
 572 MOVOP:
 573         XOR     AX,AX
 574         JMP     SHORT GROUPM
 575
 576 ;   ADD, ADC, SUB, SBB, CMP, AND, OR, XOR instructions
 577
 578 GROUP2:
 579         MOV     BYTE PTR [ASSEM1],10000000B
 580 GROUPM:
 581         MOV     BYTE PTR [MIDFLD],AL
 582
 583         PUSH    AX
 584         CALL    GETREGMEM
 585         CALL    BUILD2
 586         CALL    SCANP                   ; POINT TO NEXT OPERAND
 587         MOV     AL,BYTE PTR [ASSEM_CNT]
 588         PUSH    AX
 589         CALL    GETREGMEM
 590         POP     AX
 591         MOV     BYTE PTR [DI],AL
 592         POP     AX
 593         MOV     BL,BYTE PTR [AWORD]
 594         OR      BL,BL
 595         JZ      ERRV5
 596         DEC     BL
 597         AND     BL,1
 598         OR      BYTE PTR [DI+1],BL
 599
 600         CMP     BYTE PTR [MEMFLG],0
 601         JNZ     G21V
 602         CMP     BYTE PTR [NUMFLG],0     ; TEST FOR IMMEDIATE DATA
 603         JZ      G21V
 604         CMP     BYTE PTR [SEGFLG],0
 605         JNZ     ERRV5
 606         CMP     BYTE PTR [TSTFLG],2     ; XCHG?
 607         JNZ     IMMED1
 608 ERRV5:
 609         JMP     ASMERR
 610 G21V:
 611         JMP     GRP21
 612
 613 ;  SECOND OPERAND WAS IMMEDIATE
 614
 615 IMMED1:
 616         MOV     AL,BYTE PTR [DI+2]
 617         CMP     BYTE PTR [MOVFLG],0
 618         JZ      NOTMOV1
 619         AND     AL,11000000B
 620         CMP     AL,11000000B
 621         JNZ     GRP23                   ; not to a register
 622                                         ; MOVE IMMEDIATE TO REGISTER
 623         MOV     AL,BYTE PTR [DI+1]
 624         AND     AL,1                    ; SET SIZE
 625         PUSHF
 626         SHL     AL,1
 627         SHL     AL,1
 628         SHL     AL,1
 629         OR      AL,BYTE PTR [DI+2]      ; SET REGISTER
 630         AND     AL,00001111B
 631         OR      AL,10110000B
 632         MOV     BYTE PTR [DI+1],AL
 633         MOV     AX,WORD PTR [LOWNUM]
 634         MOV     WORD PTR [DI+2],AX
 635         POPF
 636         JZ      EXVEC
 637         INC     BYTE PTR [DI]
 638 EXVEC:
 639         JMP     GRPEX
 640
 641 NOTMOV1:
 642         AND     AL,11000111B
 643         CMP     AL,11000000B
 644         JZ      IMMACC                  ; IMMEDIATE TO ACC
 645
 646         CMP     BYTE PTR [TSTFLG],0
 647         JNZ     GRP23
 648         CMP     BYTE PTR [MIDFLD],1*8   ; OR?
 649         JZ      GRP23
 650         CMP     BYTE PTR [MIDFLD],4*8   ; AND?
 651         JZ      GRP23
 652         CMP     BYTE PTR [MIDFLD],6*8   ; XOR?
 653         JZ      GRP23
 654         TEST    BYTE PTR [DI+1],1       ; TEST IF BYTE OPCODE
 655         JZ      GRP23
 656
 657         MOV     AX,[LOWNUM]
 658         MOV     BX,AX
 659         CBW
 660         CMP     AX,BX
 661         JNZ     GRP23                   ; SMALL ENOUGH?
 662
 663         MOV     BL,[DI]
 664         DEC     BYTE PTR [DI]
 665         OR      BYTE PTR [DI+1],10B
 666         JMP     SHORT GRP23X
 667
 668 IMMACC:
 669         MOV     AL,BYTE PTR [DI+1]
 670         AND     AL,1
 671         CMP     BYTE PTR [TSTFLG],0
 672         JZ      NOTTST
 673         OR      AL,10101000B
 674         JMP     SHORT TEST1
 675 NOTTST:
 676         OR      AL,BYTE PTR [MIDFLD]
 677         OR      AL,100B
 678 TEST1:
 679         MOV     BYTE PTR [DI+1],AL
 680         DEC     BYTE PTR [DI]
 681
 682 GRP23:
 683         MOV     BL,BYTE PTR [DI]
 684 GRP23X:
 685         XOR     BH,BH
 686         ADD     BX,DI
 687         INC     BX
 688         MOV     AX,WORD PTR [LOWNUM]
 689         MOV     WORD PTR [BX],AX
 690         INC     BYTE PTR [DI]
 691         TEST    BYTE PTR [DI+1],1
 692         JZ      GRPEX1
 693         INC     BYTE PTR [DI]
 694 GRPEX1:
 695         JMP     GRPEX
 696
 697 ;       SECOND OPERAND WAS MEMORY OR REGISTER
 698
 699 GRP21:
 700         CMP     BYTE PTR [SEGFLG],0
 701         JZ      GRP28                   ; FIRST OPERAND WAS A SEGMENT REG
 702         MOV     AL,BYTE PTR [REGMEM]
 703         TEST    AL,10000B
 704         JZ      NOTSEG1
 705 ERRV3:
 706         JMP     ASMERR
 707 NOTSEG1:
 708         AND     AL,111B
 709         OR      BYTE PTR [DI+2],AL
 710         AND     BYTE PTR [DI+1],11111110B
 711         CMP     BYTE PTR [MEMFLG],0
 712         JNZ     G22V
 713         JMP     GRPEX
 714
 715 GRP28:
 716         AND     BYTE PTR [DI+2],11000111B
 717         MOV     AL,BYTE PTR [DI+1]      ; GET FIRST OPCODE
 718         AND     AL,1B
 719         CMP     BYTE PTR [MOVFLG],0
 720         JZ      NOTMOV2
 721         OR      AL,10001000B
 722         JMP     SHORT MOV1
 723 NOTMOV2:
 724         CMP     BYTE PTR [TSTFLG],0
 725         JZ      NOTTST2
 726         OR      AL,10000100B
 727         CMP     BYTE PTR [TSTFLG],2
 728         JNZ     NOTTST2
 729         OR      AL,10B
 730 NOTTST2:
 731         OR      AL,BYTE PTR [MIDFLD]    ; MIDFLD IS ZERO FOR TST
 732 MOV1:
 733         MOV     BYTE PTR [DI+1],AL
 734         CMP     BYTE PTR [MEMFLG],0
 735 G22V:
 736         JZ      NotGRP22
 737         JMP     GRP22
 738 NotGRP22:
 739
 740 ;       SECOND OPERAND WAS A REGISTER
 741
 742         MOV     AL,BYTE PTR [REGMEM]
 743         TEST    AL,10000B               ; SEGMENT REGISTER?
 744         JZ      NOTSEG
 745         CMP     BYTE PTR [MOVFLG],0
 746         JZ      ERRV3
 747         MOV     BYTE PTR [DI+1],10001100B
 748
 749 NOTSEG:
 750         AND     AL,111B
 751         SHL     AL,1
 752         SHL     AL,1
 753         SHL     AL,1
 754         OR      BYTE PTR [DI+2],AL
 755 ; ARR 2.4
 756 ; In the case of the XCHG reg,reg and TEST reg,reg we have just built the
 757 ; instruction backwards.  This is because these two instructions do not have
 758 ; the D bit.  We need to switch R/S and REG
 759 ;
 760 ; Good comment Aaron, except that we do NOT switch if a memory operand was
 761 ; present for precisely the reason that the D bit is not present
 762 ;
 763         CMP     BYTE PTR [TSTFLG],0
 764         JZ      NOSWITCH                ; Not XCHG or TEST
 765 ;
 766 ; See if there is a memory operand specified.  If the MOD field is 11, then
 767 ; we do perform the exchange.
 768 ;
 769         MOV     AH,[DI+2]
 770         AND     AH,MASKMOD
 771         CMP     AH,MASKMOD
 772         JNZ     NOSWITCH
 773         MOV     AH,BYTE PTR [DI+2]
 774         AND     AH,MASKRM
 775         SHL     AH,1                    ; Low three bits to middle three
 776         SHL     AH,1
 777         SHL     AH,1
 778         MOV     AL,BYTE PTR [DI+2]
 779         AND     AL,MASKREG
 780         SHR     AL,1                    ; Middle three to low three
 781         SHR     AL,1
 782         SHR     AL,1
 783         OR      AL,AH                   ; Re combine
 784         AND     BYTE PTR [DI+2],MASKMOD ; Zap original
 785         OR      BYTE PTR [DI+2],AL      ; New low 6 bits
 786 NOSWITCH:
 787
 788
 789 ; SPECIAL FORM OF THE EXCHANGE COMMAND
 790
 791         CMP     BYTE PTR [TSTFLG],2
 792         JNZ     GRPEX
 793         TEST    BYTE PTR [DI+1],1
 794         JZ      GRPEX
 795         PUSH    AX
 796         MOV     AL,BYTE PTR [DI+2]
 797         AND     AL,MASKMOD
 798         CMP     AL,MASKMOD              ; MUST BE REGISTER TO REGISTER
 799         POP     AX
 800         JB      GRPEX
 801         OR      AL,AL
 802         JZ      SPECX
 803         MOV     AL,[DI+2]
 804         AND     AL,MASKRM
 805         JNZ     GRPEX
 806         MOV     CL,3
 807         SHR     BYTE PTR [DI+2],CL
 808 SPECX:
 809         MOV     AL,[DI+2]
 810         AND     AL,MASKRM
 811         OR      AL,10010000B
 812         MOV     BYTE PTR [DI+1],AL
 813         DEC     BYTE PTR [DI]
 814         JMP     SHORT GRPEX
 815
 816 ;  SECOND OPERAND WAS A MEMORY REFERENCE
 817
 818 GRP22:
 819         CMP     BYTE PTR [TSTFLG],0
 820         JNZ     TST2
 821         OR      BYTE PTR [DI+1],10B
 822 TST2:
 823         MOV     AL,BYTE PTR [DI+2]
 824         CMP     AL,MASKMOD              ; MUST BE A REGISTER
 825         JB      ASMERR
 826         CMP     BYTE PTR [SEGFLG],0
 827         JZ      GRP223
 828         AND     AL,00011000B
 829         JMP     SHORT GRP222
 830 GRP223:
 831         AND     AL,MASKRM
 832         SHL     AL,1
 833         SHL     AL,1
 834         SHL     AL,1
 835 GRP222:
 836         OR      AL,BYTE PTR [MODE]
 837         OR      AL,BYTE PTR [REGMEM]
 838         MOV     BYTE PTR [DI+2],AL
 839         MOV     AX,WORD PTR [LOWNUM]
 840         MOV     WORD PTR [DI+3],AX
 841 GRPSIZ:
 842         MOV     BYTE PTR [DI],2
 843         MOV     AL,BYTE PTR [DI+2]
 844         AND     AL,11000111B
 845         CMP     AL,00000110B
 846         JZ      GRP24
 847         AND     AL,MASKMOD
 848         CMP     AL,01000000B
 849         JZ      GRP25
 850         CMP     AL,10000000B
 851         JNZ     GRPEX
 852 GRP24:
 853         INC     BYTE PTR [DI]
 854 GRP25:
 855         INC     BYTE PTR [DI]
 856
 857 GRPEX:
 858         CMP     BYTE PTR [MOVFLG],0
 859         JZ      ASSEM_EXIT
 860
 861 ;       TEST FOR SPECIAL FORM OF MOV AX,[MEM] OR MOV [MEM],AX
 862
 863         MOV     AL,[DI+1]               ; GET OP-CODE
 864         AND     AL,11111100B
 865         CMP     AL,10001000B
 866         JNZ     ASSEM_EXIT
 867         CMP     BYTE PTR [DI+2],00000110B ; MEM TO AX OR AX TO MEM
 868         JNZ     ASSEM_EXIT
 869         MOV     AL,BYTE PTR [DI+1]
 870         AND     AL,11B
 871         XOR     AL,10B
 872         OR      AL,10100000B
 873         MOV     BYTE PTR [DI+1],AL
 874         DEC     BYTE PTR [DI]
 875         MOV     AX,[DI+3]
 876         MOV     WORD PTR [DI+2],AX
 877
 878 ASSEM_EXIT:
 879         CALL    STUFF_BYTES
 880         JMP     ASSEMLOOP
 881
 882 ; Assem error. SI points to character in the input buffer
 883 ; which caused error. By subtracting from start of buffer,
 884 ; we will know how far to tab over to appear directly below
 885 ; it on the terminal. Then print "^ Error".
 886
 887 ASMERR:
 888         SUB     SI,OFFSET DG:(BYTEBUF-10) ; How many char processed so far?
 889         MOV     CX,SI                   ; Parameter for TAB in CX
 890         MOV     DI,OFFSET DG:ARG_BUF
 891         CALL    TAB                     ; Directly below bad char
 892         MOV     BYTE PTR [DI],0
 893         MOV     DX,OFFSET DG:SYNERR_PTR ; Error message
 894         CALL    PRINTF_CRLF
 895         JMP     ASSEMLOOP
 896 ;
 897 ;  assemble the different parts into an instruction
 898 ;
 899 BUILDIT:
 900         MOV     AL,BYTE PTR [AWORD]
 901         OR      AL,AL
 902         JNZ     BUILD1
 903 BLDERR:
 904         JMP     ASMERR
 905
 906 BUILD1:
 907         DEC     AL
 908         OR      BYTE PTR [DI+1],AL      ; SET THE SIZE
 909
 910 BUILD2:
 911         CMP     BYTE PTR [NUMFLG],0     ; TEST FOR IMMEDIATE DATA
 912         JZ      BUILD3
 913         CMP     BYTE PTR [MEMFLG],0
 914         JZ      BLDERR
 915
 916 BUILD3:
 917         MOV     AL,BYTE PTR [REGMEM]
 918         CMP     AL,-1
 919         JZ      BLD1
 920         TEST    AL,10000B               ; TEST IF SEGMENT REGISTER
 921         JZ      BLD1
 922         CMP     BYTE PTR [MOVFLG],0
 923         JZ      BLDERR
 924         MOV     WORD PTR [DI+1],10001110B
 925         INC     BYTE PTR [MOVFLG]
 926         INC     BYTE PTR [SEGFLG]
 927         AND     AL,00000011B
 928         SHL     AL,1
 929         SHL     AL,1
 930         SHL     AL,1
 931         OR      AL,MASKMOD
 932         MOV     BYTE PTR [DI+2],AL
 933         RET
 934
 935 BLD1:
 936         AND     AL,00000111B
 937 BLD4:
 938         OR      AL,BYTE PTR [MODE]
 939         OR      AL,BYTE PTR [MIDFLD]
 940         MOV     BYTE PTR [DI+2],AL
 941         MOV     AX,WORD PTR [LOWNUM]
 942         MOV     WORD PTR [DI+3],AX
 943         RET
 944
 945 GETREGMEM:
 946         MOV     BYTE PTR [F8087],0
 947 GETREGMEM2:
 948         CALL    SCANP
 949         XOR     AX,AX
 950         MOV     WORD PTR [LOWNUM],AX    ; OFFSET
 951         MOV     WORD PTR [DIFLG],AX     ; DIFLG+SIFLG
 952         MOV     WORD PTR [BXFLG],AX     ; BXFLG+BPFLG
 953         MOV     WORD PTR [NEGFLG],AX    ; NEGFLG+NUMFLG
 954         MOV     WORD PTR [MEMFLG],AX    ; MEMFLG+REGFLG
 955         DEC     AL
 956         CMP     BYTE PTR [F8087],0
 957         JZ      PUTREG
 958         MOV     AL,1                    ; DEFAULT 8087 REG IS 1
 959 PUTREG:
 960         MOV     BYTE PTR [REGMEM],AL
 961
 962 GETLOOP:
 963         MOV     BYTE PTR [NEGFLG],0
 964 GETLOOP1:
 965         MOV     AX,WORD PTR [SI]
 966         CMP     AL,','
 967         JZ      GOMODE
 968         CMP     AL,13
 969         JZ      GOMODE
 970         CMP     AL,';'
 971         JZ      GOMODE
 972         CMP     AL,9
 973         JZ      GETTB
 974         CMP     AL,' '
 975         JNZ     GOGET
 976 GETTB:
 977         INC     SI
 978         JMP     GETLOOP1
 979 GOGET:
 980         JMP     GETINFO
 981
 982 ;  DETERMINE THE MODE BITS
 983
 984 GOMODE:
 985         MOV     DI,OFFSET DG:ASSEM_CNT
 986         MOV     BYTE PTR [MODE],11000000B
 987         MOV     BYTE PTR [ASSEM_CNT],2
 988         CMP     BYTE PTR [MEMFLG],0
 989         JNZ     GOMODE1
 990         MOV     AL,[NUMFLG]
 991         OR      AL,[REGFLG]
 992         JNZ     MORET
 993         OR      AL,[F8087]
 994         JZ      ERRET
 995         MOV     AL,[DI+1]
 996         OR      AL,[DIRFLG]
 997         CMP     AL,0DCH                 ; ARITHMETIC?
 998         JNZ     MORET
 999         MOV     BYTE PTR [DI+1],0DEH    ; ADD POP TO NULL ARG 8087
1000 MORET:
1001         RET
1002 ERRET:
1003         JMP     ASMERR
1004
1005 GOMODE1:
1006         MOV     BYTE PTR [MODE],0
1007         CMP     BYTE PTR [NUMFLG],0
1008         JZ      GOREGMEM
1009
1010         MOV     BYTE PTR [DI],4
1011         MOV     AX,WORD PTR [DIFLG]
1012         OR      AX,WORD PTR [BXFLG]
1013         JNZ     GOMODE2
1014         MOV     BYTE PTR [REGMEM],00000110B
1015         RET
1016
1017 GOMODE2:
1018         MOV     BYTE PTR [MODE],10000000B
1019         CALL    CHKSIZ1
1020         CMP     CL,2
1021         JZ      GOREGMEM
1022         DEC     BYTE PTR [DI]
1023         MOV     BYTE PTR [MODE],01000000B
1024
1025 ;  DETERMINE THE REG-MEM BITS
1026
1027 GOREGMEM:
1028         MOV     BX,WORD PTR [BXFLG]
1029         MOV     CX,WORD PTR [DIFLG]
1030         XOR     DX,DX
1031 GOREG0:
1032         MOV     AL,BL                   ; BX
1033         ADD     AL,CH                   ; SI
1034         CMP     AL,2
1035         JZ      GOGO
1036         INC     DL
1037         MOV     AL,BL
1038         ADD     AL,CL
1039         CMP     AL,2
1040         JZ      GOGO
1041         INC     DL
1042         MOV     AL,BH
1043         ADD     AL,CH
1044         CMP     AL,2
1045         JZ      GOGO
1046         INC     DL
1047         MOV     AL,BH
1048         ADD     AL,CL
1049         CMP     AL,2
1050         JZ      GOGO
1051         INC     DL
1052         OR      CH,CH
1053         JNZ     GOGO
1054         INC     DL
1055         OR      CL,CL
1056         JNZ     GOGO
1057         INC     DL                      ; BP+DISP
1058         OR      BH,BH
1059         JZ      GOREG1
1060         CMP     BYTE PTR [MODE],0
1061         JNZ     GOGO
1062         MOV     BYTE PTR [MODE],01000000B
1063         INC     BYTE PTR [DI]
1064         DEC     DL
1065 GOREG1:
1066         INC     DL                      ; BX+DISP
1067 GOGO:
1068         MOV     BYTE PTR [REGMEM],DL
1069         RET
1070
1071 GETINFO:
1072         CMP     AX,'EN'                 ; NEAR
1073         JNZ     GETREG3
1074 GETREG0:
1075         MOV     DL,2
1076 GETRG01:
1077         CALL    SETSIZ1
1078 GETREG1:
1079         CALL    SCANS
1080         MOV     AX,WORD PTR [SI]
1081         CMP     AX,"TP"                 ; PTR
1082         JZ      GETREG1
1083         JMP     GETLOOP
1084
1085 GETREG3:
1086         MOV     CX,5
1087         MOV     DI,OFFSET DG:SIZ8
1088         CALL    CHKREG                  ; LOOK FOR BYTE, WORD, DWORD, ETC.
1089         JZ      GETREG41
1090         INC     AL
1091         MOV     DL,AL
1092         JMP     GETRG01
1093
1094 GETREG41:
1095         MOV     AX,[SI]
1096         CMP     BYTE PTR [F8087],0
1097         JZ      GETREG5
1098         CMP     AX,"TS"                 ; 8087 STACK OPERAND
1099         JNZ     GETREG5
1100         CMP     BYTE PTR [SI+2],','
1101         JNZ     GETREG5
1102         MOV     BYTE PTR [DIRFLG],0
1103         ADD     SI,3
1104         JMP     GETLOOP
1105
1106 GETREG5:
1107         CMP     AX,"HS"                 ; SHORT
1108         JZ      GETREG1
1109
1110         CMP     AX,"AF"                 ; FAR
1111         JNZ     GETRG51
1112         CMP     BYTE PTR [SI+2],'R'
1113         JNZ     GETRG51
1114         ADD     SI,3
1115         MOV     DL,4
1116         JMP     GETRG01
1117
1118 GETRG51:
1119         CMP     AL,'['
1120         JNZ     GETREG7
1121 GETREG6:
1122         INC     BYTE PTR [MEMFLG]
1123 GETREGADD:
1124         INC     SI
1125         JMP     GETLOOP
1126
1127 GETREG7:
1128         CMP     AL,']'
1129         JZ      GETREG6
1130         CMP     AL,'.'
1131         JZ      GETREG6
1132         CMP     AL,'+'
1133         JZ      GETREGAdd
1134         CMP     AL,'-'
1135         JNZ     GETREG8
1136         INC     BYTE PTR [NEGFLG]
1137         INC     SI
1138         JMP     GETLOOP1
1139
1140 GETREG8:                                ; LOOK FOR A REGISTER
1141         CMP     BYTE PTR [F8087],0
1142         JZ      GETREGREG
1143         CMP     AX,"TS"
1144         JNZ     GETREGREG
1145         CMP     BYTE PTR [SI+2],'('
1146         JNZ     GETREGREG
1147         CMP     BYTE PTR [SI+4],')'
1148         JNZ     ASMPOP
1149         MOV     AL,[SI+3]
1150         SUB     AL,'0'
1151         JB      ASMPOP
1152         CMP     AL,7
1153         JA      ASMPOP
1154         MOV     [REGMEM],AL
1155         INC     BYTE PTR [REGFLG]
1156         ADD     SI,5
1157         CMP     WORD PTR [SI],"S,"
1158         JNZ     ZLOOP
1159         CMP     BYTE PTR [SI+2],'T'
1160         JNZ     ZLOOP
1161         ADD     SI,3
1162 ZLOOP:
1163         JMP     GETLOOP
1164
1165 GETREGREG:
1166         MOV     CX,20
1167         MOV     DI,OFFSET DG:REG8
1168         CALL    CHKREG
1169         JZ      GETREG12                ; CX = 0 MEANS NO REGISTER
1170         MOV     BYTE PTR [REGMEM],AL
1171         INC     BYTE PTR [REGFLG]       ; TELL EVERYONE WE FOUND A REG
1172         CMP     BYTE PTR [MEMFLG],0
1173         JNZ     NOSIZE
1174         CALL    SETSIZ
1175 INCSI2:
1176         ADD     SI,2
1177         JMP     GETLOOP
1178
1179 NOSIZE:
1180         CMP     AL,11                   ; BX REGISTER?
1181         JNZ     GETREG9
1182         CMP     WORD PTR [BXFLG],0
1183         JZ      GETOK
1184 ASMPOP:
1185         JMP     ASMERR
1186
1187 GETOK:
1188         INC     BYTE PTR [BXFLG]
1189         JMP     INCSI2
1190 GETREG9:
1191         CMP     AL,13                   ; BP REGISTER?
1192         JNZ     GETREG10
1193         CMP     WORD PTR [BXFLG],0
1194         JNZ     ASMPOP
1195         INC     BYTE PTR [BPFLG]
1196         JMP     INCSI2
1197 GETREG10:
1198         CMP     AL,14                   ; SI REGISTER?
1199         JNZ     GETREG11
1200         CMP     WORD PTR [DIFLG],0
1201         JNZ     ASMPOP
1202         INC     BYTE PTR [SIFLG]
1203         JMP     INCSI2
1204 GETREG11:
1205         CMP     AL,15                   ; DI REGISTER?
1206         JNZ     ASMPOP                  ; *** error
1207         CMP     WORD PTR [DIFLG],0
1208         JNZ     ASMPOP
1209         INC     BYTE PTR [DIFLG]
1210         JMP     INCSI2
1211
1212 GETREG12:                               ; BETTER BE A NUMBER!
1213         MOV     BP,WORD PTR [ASMADD+2]
1214         CMP     BYTE PTR [MEMFLG],0
1215         JZ      GTRG121
1216 GTRG119:
1217         MOV     CX,4
1218 GTRG120:
1219         CALL    GETHX
1220         JMP     SHORT GTRG122
1221 GTRG121:
1222         MOV     CX,2
1223         CMP     BYTE PTR [AWORD],1
1224         JZ      GTRG120
1225         CMP     BYTE PTR [AWORD],CL
1226         JZ      GTRG119
1227         CALL    GET_ADDRESS
1228 GTRG122:
1229         JC      ASMPOP
1230         MOV     [HINUM],AX
1231         CMP     BYTE PTR [NEGFLG],0
1232         JZ      GETREG13
1233         NEG     DX
1234 GETREG13:
1235         ADD     WORD PTR [LOWNUM],DX
1236         INC     BYTE PTR [NUMFLG]
1237 GETLOOPV:
1238         JMP     GETLOOP
1239
1240 CHKREG:
1241         PUSH    CX
1242         INC     CX
1243         REPNZ   SCASW
1244         POP     AX
1245         SUB     AX,CX
1246         OR      CX,CX
1247         RET
1248
1249 STUFF_BYTES:
1250         PUSH    SI
1251         LES     DI,DWORD PTR ASMADD
1252         MOV     SI,OFFSET DG:ASSEM_CNT
1253         XOR     AX,AX
1254         LODSB
1255         MOV     CX,AX
1256         JCXZ    STUFFRET
1257         REP     MOVSB
1258         MOV     WORD PTR [ASMADD],DI
1259 STUFFRET:
1260         POP     SI
1261         RET
1262
1263 SETSIZ:
1264         MOV     DL,1
1265         TEST    AL,11000B               ; 16 BIT OR SEGMENT REGISTER?
1266         JZ      SETSIZ1
1267         INC     DL
1268 SETSIZ1:
1269         CMP     BYTE PTR [AWORD],0
1270         JZ      SETSIZ2
1271         CMP     BYTE PTR [AWORD],DL
1272         JZ      SETSIZ2
1273 SETERR:
1274         POP     DX
1275         JMP     ASMPOP
1276 SETSIZ2:
1277         MOV     BYTE PTR [AWORD],DL
1278         RET
1279
1280 ;  DETERMINE IF NUMBER IN AX:DX IS 8 BITS, 16 BITS, OR 32 BITS
1281
1282 CHKSIZ:
1283         MOV     CL,4
1284         CMP     AX,BP
1285         JNZ     RETCHK
1286 CHKSIZ1:
1287         MOV     CL,2
1288         MOV     AX,DX
1289         CBW
1290         CMP     AX,DX
1291         JNZ     RETCHK
1292         DEC     CL
1293 RETCHK:
1294         RET
1295
1296 ;  get first character after first space
1297
1298 SCANS:
1299         CMP     BYTE PTR [SI],13
1300         JZ      RETCHK
1301         CMP     BYTE PTR [SI],'['
1302         JZ      RETCHK
1303         LODSB
1304         CMP     AL,' '
1305         JZ      SCANBV
1306         CMP     AL,9
1307         JNZ     SCANS
1308 SCANBV:
1309         JMP     SCANB
1310
1311 ; Set up for 8087 op-codes
1312
1313 SETMID:
1314         MOV     BYTE PTR [ASSEM1],0D8H
1315         MOV     AH,AL
1316         AND     AL,111B                 ; SET MIDDLE BITS OF SECOND BYTE
1317         SHL     AL,1
1318         SHL     AL,1
1319         SHL     AL,1
1320         MOV     [MIDFLD],AL
1321         MOV     AL,AH                   ; SET LOWER BITS OF FIRST BYTE
1322         SHR     AL,1
1323         SHR     AL,1
1324         SHR     AL,1
1325         OR      [ASSEM1],AL
1326         MOV     BYTE PTR [F8087],1      ; INDICATE 8087 OPERAND
1327         MOV     BYTE PTR [DIRFLG],100B
1328         RET
1329
1330 ; Set MF bits for 8087 op-codes
1331
1332 SETMF:
1333         MOV     AL,[AWORD]
1334         TEST    BYTE PTR [DI+1],10B
1335         JNZ     SETMFI
1336         AND     BYTE PTR [DI+1],11111001B ; CLEAR MF BITS
1337         CMP     AL,3                    ; DWORD?
1338         JZ      SETMFRET
1339         CMP     AL,4                    ; QWORD?
1340         JZ      SETMFRET2
1341         TEST    BYTE PTR [DI+1],1
1342         JZ      SETMFERR
1343         CMP     AL,5                    ; TBYTE?
1344         JZ      SETMFRET3
1345         JMP     SHORT SETMFERR
1346
1347 SETMFI:
1348         CMP     AL,3                    ; DWORD?
1349         JZ      SETMFRET
1350         CMP     AL,2                    ; WORD?
1351         JZ      SETMFRET2
1352         TEST    BYTE PTR [DI+1],1
1353         JZ      SETMFERR
1354         CMP     AL,4                    ; QWORD?
1355         JNZ     SETMFERR
1356         OR      BYTE PTR [DI+1],111B
1357 SETMFRET3:
1358         OR      BYTE PTR [DI+1],011B
1359         OR      BYTE PTR [DI+2],101000B
1360         JMP     SHORT SETMFRET
1361 SETMFRET2:
1362         OR      BYTE PTR [DI+1],100B
1363 SETMFRET:
1364         RET
1365
1366 SETMFERR:
1367         JMP     ASMPOP
1368
1369
1370 DW_OPER:
1371         MOV     BP,1
1372         JMP     SHORT DBEN
1373
1374 DB_OPER:
1375         XOR     BP,BP
1376 DBEN:
1377         MOV     DI,OFFSET DG:ASSEM_CNT
1378         DEC     BYTE PTR [DI]
1379         INC     DI
1380 DB0:
1381         XOR     BL,BL
1382         CALL    SCANP
1383         JNZ     DB1
1384 DBEX:
1385         JMP     ASSEM_EXIT
1386 DB1:
1387         OR      BL,BL
1388         JNZ     DB3
1389         MOV     BH,BYTE PTR [SI]
1390         CMP     BH,"'"
1391         JZ      DB2
1392         CMP     BH,'"'
1393         JNZ     DB4
1394 DB2:
1395         INC     SI
1396         INC     BL
1397 DB3:
1398         LODSB
1399         CMP     AL,13
1400         JZ      DBEX
1401         CMP     AL,BH
1402         JZ      DB0
1403         STOSB
1404         INC     BYTE PTR [ASSEM_CNT]
1405         JMP     DB3
1406 DB4:
1407         MOV     CX,2
1408         CMP     BP,0
1409         JZ      DB41
1410         MOV     CL,4
1411 DB41:
1412         PUSH    BX
1413         CALL    GETHX
1414         POP     BX
1415         JNC     DB5
1416         JMP     ASMERR
1417 DB5:
1418         MOV     AX,DX
1419         CMP     BP,0
1420         JZ      DB6
1421         STOSW
1422         INC     BYTE PTR [ASSEM_CNT]
1423         JMP     SHORT DB7
1424 DB6:
1425         STOSB
1426 DB7:
1427         INC     BYTE PTR [ASSEM_CNT]
1428         JMP     DB0
1429
1430 ; ORG pseudo op
1431
1432 DOORG:
1433         MOV     BP,WORD PTR ASMADD+2
1434         CALL    GET_ADDRESS
1435         MOV     WORD PTR ASMADD,DX
1436         MOV     WORD PTR ASMADD+2,AX
1437         JMP     ASSEMLOOP
1438
1439 CODE    ENDS
1440         END     ASSEM
1441 \1a