summaryrefslogtreecommitdiff
path: root/v4.0/src/CMD/DEBUG/DEBASM.ASM
diff options
context:
space:
mode:
Diffstat (limited to 'v4.0/src/CMD/DEBUG/DEBASM.ASM')
-rw-r--r--v4.0/src/CMD/DEBUG/DEBASM.ASM1441
1 files changed, 1441 insertions, 0 deletions
diff --git a/v4.0/src/CMD/DEBUG/DEBASM.ASM b/v4.0/src/CMD/DEBUG/DEBASM.ASM
new file mode 100644
index 0000000..8f34c52
--- /dev/null
+++ b/v4.0/src/CMD/DEBUG/DEBASM.ASM
@@ -0,0 +1,1441 @@
1 PAGE 80,132 ;
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
16CODE SEGMENT PUBLIC BYTE
17CODE ENDS
18
19CONST 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
24CONST ENDS
25
26CSTACK SEGMENT STACK
27CSTACK ENDS
28
29DATA 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
40DATA ENDS
41
42DG GROUP CODE,CONST,CSTACK,DATA
43
44CODE SEGMENT PUBLIC BYTE
45ASSUME 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
61MASKMOD EQU 11000000B
62SHMOD EQU 6
63MASKREG EQU 00111000B
64SHREG EQU 3
65MASKRM EQU 00000111B
66SHRM EQU 0
67
68ASSEM:
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
76ASSEMLOOP:
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...
97OPLOOK:
98 XOR CX,CX ; OP-CODE COUNT = 0
99 MOV DI,OFFSET DG:DBMN
100OPSCAN:
101 XOR BX,BX
102OPLOOP:
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
110OP1:
111 INC DI ; SCAN FOR NEXT OP-CODE...
112 CMP BYTE PTR [DI-1],0
113 JNZ OP1
114 JMP OPSCAN
115
116OPMATCH:
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
144FDE_OPER:
145 MOV AH,0DEH
146 JMP SHORT FDX_OPER
147FDB_OPER:
148 MOV AH,0DBH
149 JMP SHORT FDX_OPER
150FD9_OPER:
151 MOV AH,0D9H
152FDX_OPER:
153 XCHG AL,AH
154 MOV WORD PTR [ASSEM1],AX
155
156; AAD AND AAM INSTRUCIONS
157
158AA_OPER:
159 INC BYTE PTR [ASSEM_CNT]
160
161; INSTRUCTIONS WITH NO OPERANDS
162
163NO_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
173PUSH_OPER:
174 MOV AH,11111111B
175 JMP SHORT POP1
176
177; POP INSTRUCTION
178
179POP_OPER:
180 MOV AH,10001111B
181POP1:
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
201POP2:
202 AND AL,MASKRM
203 OR AL,01010000B
204 CMP BYTE PTR [MIDFLD],0
205 JNZ POP3
206 OR AL,01011000B
207POP3:
208 MOV BYTE PTR [DI+1],AL
209 JMP ASSEM_EXIT
210
211; RET AND RETF INSTRUCTIONS
212
213GET_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
221DATRET:
222 JMP ASSEM_EXIT
223
224
225; INT INSTRUCTION
226
227INT_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
240IN_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
247ERRV1:
248 JMP ASMERR
249IN_0:
250 INC BYTE PTR [ASSEM1]
251IN_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
264OUT_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
271OUT_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
278OUT_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
291JMP_OPER:
292 INC BYTE PTR [TSTFLG]
293
294; CALL INSTRUCTION
295
296CALL_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
308CALLJ1:
309 CMP BYTE PTR [AWORD],1
310ERRZ4:
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
319CALLJ2:
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
330CALLJ3:
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
339CALLJ5:
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
348CALLJ6:
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]
371ASMEX4:
372 JMP ASSEM_EXIT
373
374; CONDITIONAL JUMPS AND LOOP INSTRUCTIONS
375
376DISP8_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
385DISPX:
386 INC [ASSEM_CNT]
387 MOV BYTE PTR [ASSEM2],AL
388ASMEX3:
389 JMP ASSEM_EXIT
390
391; LDS, LES, AND LEA INSTRUCTIONS
392
393L_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
413DCINC_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]
427ASEXV:
428 JMP ASSEM_EXIT
429
430ERRV2:
431 JMP ASMERR
432
433; ESC INSTRUCTION
434
435ESC_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
455FGROUPDS:
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
470FGROUPX:
471 CALL SETMID ; THIS ENTRY POINT FOR 1 MEM OPER
472 MOV BYTE PTR [DIRFLG],0
473 JMP SHORT FGRP2
474FGROUP:
475 CALL SETMID
476FGRP2:
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
484FGROUP1:
485 CALL SETMF
486FEXIT:
487 JMP ASSEM_EXIT
488
489; THESE 8087 INSTRUCTIONS REQUIRE A MEMORY OPERAND
490FGROUPB:
491 MOV AH,5 ; MUST BE TBYTE
492 JMP SHORT FGROUP3E
493FGROUP3W:
494 MOV AH,2 ; MUST BE WORD
495 JMP SHORT FGROUP3E
496FGROUP3:
497 MOV AH,-1 ; SIZE CANNOT BE SPECIFIED
498FGROUP3E:
499 MOV [AWORD],AH
500 CALL SETMID
501 CALL GETREGMEM
502 CMP BYTE PTR [MODE],11000000B
503 JZ FGRPERR
504FGRP:
505 CALL BUILD3
506 JMP FEXIT
507
508; THESE 8087 INSTRUCTIONS REQUIRE A REGISTER OPERAND
509FGROUPP: ; 8087 POP OPERANDS
510 MOV BYTE PTR [AWORD],-1
511 CALL SETMID
512 CALL GETREGMEM2
513 CMP BYTE PTR [DIRFLG],0
514 JNZ FGRP
515FGRPERR:
516 JMP ASMERR
517
518FGROUPZ: ; 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
530GROUP1:
531 MOV [ASSEM1],11110110B
532GROUPE:
533 MOV BYTE PTR [MIDFLD],AL
534 CALL GETREGMEM
535 CALL BUILDIT
536 JMP FEXIT
537
538; SHIFT AND ROTATE INSTRUCTIONS
539
540ROTOP:
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
550ROTERR:
551 JMP ASMERR
552ROTOP1:
553 OR BYTE PTR [ASSEM1],10B
554ASMEXV1:
555 JMP ASSEM_EXIT
556
557; XCHG INSTRUCTION
558
559EX_OPER:
560 INC BYTE PTR [TSTFLG]
561
562; TEST INSTRUCTION
563
564TST_OPER:
565 INC BYTE PTR [TSTFLG]
566 JMP SHORT MOVOP
567
568; MOV INSTRUCTION
569
570MOV_OPER:
571 INC BYTE PTR [MOVFLG]
572MOVOP:
573 XOR AX,AX
574 JMP SHORT GROUPM
575
576; ADD, ADC, SUB, SBB, CMP, AND, OR, XOR instructions
577
578GROUP2:
579 MOV BYTE PTR [ASSEM1],10000000B
580GROUPM:
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
608ERRV5:
609 JMP ASMERR
610G21V:
611 JMP GRP21
612
613; SECOND OPERAND WAS IMMEDIATE
614
615IMMED1:
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]
638EXVEC:
639 JMP GRPEX
640
641NOTMOV1:
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
668IMMACC:
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
675NOTTST:
676 OR AL,BYTE PTR [MIDFLD]
677 OR AL,100B
678TEST1:
679 MOV BYTE PTR [DI+1],AL
680 DEC BYTE PTR [DI]
681
682GRP23:
683 MOV BL,BYTE PTR [DI]
684GRP23X:
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]
694GRPEX1:
695 JMP GRPEX
696
697; SECOND OPERAND WAS MEMORY OR REGISTER
698
699GRP21:
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
705ERRV3:
706 JMP ASMERR
707NOTSEG1:
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
715GRP28:
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
723NOTMOV2:
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
730NOTTST2:
731 OR AL,BYTE PTR [MIDFLD] ; MIDFLD IS ZERO FOR TST
732MOV1:
733 MOV BYTE PTR [DI+1],AL
734 CMP BYTE PTR [MEMFLG],0
735G22V:
736 JZ NotGRP22
737 JMP GRP22
738NotGRP22:
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
749NOTSEG:
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
786NOSWITCH:
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
808SPECX:
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
818GRP22:
819 CMP BYTE PTR [TSTFLG],0
820 JNZ TST2
821 OR BYTE PTR [DI+1],10B
822TST2:
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
830GRP223:
831 AND AL,MASKRM
832 SHL AL,1
833 SHL AL,1
834 SHL AL,1
835GRP222:
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
841GRPSIZ:
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
852GRP24:
853 INC BYTE PTR [DI]
854GRP25:
855 INC BYTE PTR [DI]
856
857GRPEX:
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
878ASSEM_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
887ASMERR:
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;
899BUILDIT:
900 MOV AL,BYTE PTR [AWORD]
901 OR AL,AL
902 JNZ BUILD1
903BLDERR:
904 JMP ASMERR
905
906BUILD1:
907 DEC AL
908 OR BYTE PTR [DI+1],AL ; SET THE SIZE
909
910BUILD2:
911 CMP BYTE PTR [NUMFLG],0 ; TEST FOR IMMEDIATE DATA
912 JZ BUILD3
913 CMP BYTE PTR [MEMFLG],0
914 JZ BLDERR
915
916BUILD3:
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
935BLD1:
936 AND AL,00000111B
937BLD4:
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
945GETREGMEM:
946 MOV BYTE PTR [F8087],0
947GETREGMEM2:
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
959PUTREG:
960 MOV BYTE PTR [REGMEM],AL
961
962GETLOOP:
963 MOV BYTE PTR [NEGFLG],0
964GETLOOP1:
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
976GETTB:
977 INC SI
978 JMP GETLOOP1
979GOGET:
980 JMP GETINFO
981
982; DETERMINE THE MODE BITS
983
984GOMODE:
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
1000MORET:
1001 RET
1002ERRET:
1003 JMP ASMERR
1004
1005GOMODE1:
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
1017GOMODE2:
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
1027GOREGMEM:
1028 MOV BX,WORD PTR [BXFLG]
1029 MOV CX,WORD PTR [DIFLG]
1030 XOR DX,DX
1031GOREG0:
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
1065GOREG1:
1066 INC DL ; BX+DISP
1067GOGO:
1068 MOV BYTE PTR [REGMEM],DL
1069 RET
1070
1071GETINFO:
1072 CMP AX,'EN' ; NEAR
1073 JNZ GETREG3
1074GETREG0:
1075 MOV DL,2
1076GETRG01:
1077 CALL SETSIZ1
1078GETREG1:
1079 CALL SCANS
1080 MOV AX,WORD PTR [SI]
1081 CMP AX,"TP" ; PTR
1082 JZ GETREG1
1083 JMP GETLOOP
1084
1085GETREG3:
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
1094GETREG41:
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
1106GETREG5:
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
1118GETRG51:
1119 CMP AL,'['
1120 JNZ GETREG7
1121GETREG6:
1122 INC BYTE PTR [MEMFLG]
1123GETREGADD:
1124 INC SI
1125 JMP GETLOOP
1126
1127GETREG7:
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
1140GETREG8: ; 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
1162ZLOOP:
1163 JMP GETLOOP
1164
1165GETREGREG:
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
1175INCSI2:
1176 ADD SI,2
1177 JMP GETLOOP
1178
1179NOSIZE:
1180 CMP AL,11 ; BX REGISTER?
1181 JNZ GETREG9
1182 CMP WORD PTR [BXFLG],0
1183 JZ GETOK
1184ASMPOP:
1185 JMP ASMERR
1186
1187GETOK:
1188 INC BYTE PTR [BXFLG]
1189 JMP INCSI2
1190GETREG9:
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
1197GETREG10:
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
1204GETREG11:
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
1212GETREG12: ; BETTER BE A NUMBER!
1213 MOV BP,WORD PTR [ASMADD+2]
1214 CMP BYTE PTR [MEMFLG],0
1215 JZ GTRG121
1216GTRG119:
1217 MOV CX,4
1218GTRG120:
1219 CALL GETHX
1220 JMP SHORT GTRG122
1221GTRG121:
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
1228GTRG122:
1229 JC ASMPOP
1230 MOV [HINUM],AX
1231 CMP BYTE PTR [NEGFLG],0
1232 JZ GETREG13
1233 NEG DX
1234GETREG13:
1235 ADD WORD PTR [LOWNUM],DX
1236 INC BYTE PTR [NUMFLG]
1237GETLOOPV:
1238 JMP GETLOOP
1239
1240CHKREG:
1241 PUSH CX
1242 INC CX
1243 REPNZ SCASW
1244 POP AX
1245 SUB AX,CX
1246 OR CX,CX
1247 RET
1248
1249STUFF_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
1259STUFFRET:
1260 POP SI
1261 RET
1262
1263SETSIZ:
1264 MOV DL,1
1265 TEST AL,11000B ; 16 BIT OR SEGMENT REGISTER?
1266 JZ SETSIZ1
1267 INC DL
1268SETSIZ1:
1269 CMP BYTE PTR [AWORD],0
1270 JZ SETSIZ2
1271 CMP BYTE PTR [AWORD],DL
1272 JZ SETSIZ2
1273SETERR:
1274 POP DX
1275 JMP ASMPOP
1276SETSIZ2:
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
1282CHKSIZ:
1283 MOV CL,4
1284 CMP AX,BP
1285 JNZ RETCHK
1286CHKSIZ1:
1287 MOV CL,2
1288 MOV AX,DX
1289 CBW
1290 CMP AX,DX
1291 JNZ RETCHK
1292 DEC CL
1293RETCHK:
1294 RET
1295
1296; get first character after first space
1297
1298SCANS:
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
1308SCANBV:
1309 JMP SCANB
1310
1311; Set up for 8087 op-codes
1312
1313SETMID:
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
1332SETMF:
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
1347SETMFI:
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
1357SETMFRET3:
1358 OR BYTE PTR [DI+1],011B
1359 OR BYTE PTR [DI+2],101000B
1360 JMP SHORT SETMFRET
1361SETMFRET2:
1362 OR BYTE PTR [DI+1],100B
1363SETMFRET:
1364 RET
1365
1366SETMFERR:
1367 JMP ASMPOP
1368
1369
1370DW_OPER:
1371 MOV BP,1
1372 JMP SHORT DBEN
1373
1374DB_OPER:
1375 XOR BP,BP
1376DBEN:
1377 MOV DI,OFFSET DG:ASSEM_CNT
1378 DEC BYTE PTR [DI]
1379 INC DI
1380DB0:
1381 XOR BL,BL
1382 CALL SCANP
1383 JNZ DB1
1384DBEX:
1385 JMP ASSEM_EXIT
1386DB1:
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
1394DB2:
1395 INC SI
1396 INC BL
1397DB3:
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
1406DB4:
1407 MOV CX,2
1408 CMP BP,0
1409 JZ DB41
1410 MOV CL,4
1411DB41:
1412 PUSH BX
1413 CALL GETHX
1414 POP BX
1415 JNC DB5
1416 JMP ASMERR
1417DB5:
1418 MOV AX,DX
1419 CMP BP,0
1420 JZ DB6
1421 STOSW
1422 INC BYTE PTR [ASSEM_CNT]
1423 JMP SHORT DB7
1424DB6:
1425 STOSB
1426DB7:
1427 INC BYTE PTR [ASSEM_CNT]
1428 JMP DB0
1429
1430; ORG pseudo op
1431
1432DOORG:
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
1439CODE ENDS
1440 END ASSEM
1441 \ No newline at end of file
HIC SVNT DRACONES