2
    INTTBL  SEGMENT AT 0        ;жĶλַΪ0
ORG  n4                 ;nΪж,n4жƫƵַ
DD  INTVCE              ;αָDD˫ʹ洢ռ
  ;INTVCEΪжӳ
INTTBL ENDS
;ϵĶζDDαָжϷ׵ַװ뵽߼ַΪ
;0000: n4ʼ4洢Ԫ


MCODE SEGMENT            ;

INTVCE  PROC FAR        ;жϷӳ

IRET



     MOV  AX, 0
     MOV  ES, AX              ;жĶλַΪ0
     MOV  DI, n4H              ;n4HжƫƵַ
     MOV  AX, OFFSET INTVCE    ;OFFSET INTVCEֵжϷƫƵַ
     CLD
     STOSW                      ;ִеĲΪ(AX)(ES):(DI),(DI)+2(DI)
                       ;жϷӳڵַƫƵַж
     MOV  AX, SEG INTVCE       ;SEG INTVCEʽֵжϷĶεַ
     STOSW              ;жϷӳڵַĶεַж


             ܺ25HAH
             жAL
          жϴ׵ַ֮εַ ƫƵַDS DX
              INT  21H


MOV  AH,25H           ;DOSжϹܺ
    MOV  AL,n               ;nΪж
    MOV  DX,SEG INTVCE     ;SEG INTVCEʽֵжϷĶεַ
    MOV  DS,DX
    MOV  DX,OFFSET INTVCE  ;OFFSET INTVCEֵжϷƫƵַ
    INT  21H


 INTITB: MOV  AX,0
         MOV      DS,AX                ;ڴͶ
         MOV      SI,0120H             ;n=48H,4n=120H
         MOV      AX,OFFSET INTVCE     ;ȡжϴ׵ַ֮ƫƵַ 
MOV     SI,AX              ;ƫƵַдж4nַ
         MOV      AX,SEG INTVCE        ;ȡжϴ׵ַ֮εַ
         MOV     SI+2,AX            ;εַдж4n+2ַ 


3
INC     WORD PTR 500;


MOV    ECX,EDX;ECXеΪЧַ


MOV    ECXEAX+24;EAXݼλ24ɲЧַ


ADD     EAX,TABLEESI;ESIеݼTABLEĵַɲЧַ


IMUL EBX,TABLE ESI4,7;ESIеݳ4ټTABLEĵַγЧַ


MOV    EAX,ESIݣEBX;EBXеݼESIеΪЧַ


MOV    ECX,EDI4ݣEAX;EDIеݳ4ټEAXеγɲЧַ


ADD    EDX,ESIݣEBP+00FFFFF0H  ;   ESIݼEBPټ 00FFFFF0H,Ϊ
; Чַ


MOV    EAX,EDI4ݣEBP+80;EDIݳ4,EBP,ټ 80ΪЧַ


    JMP            1000H   ;תƵַָи
CALL      1000H       ;õַָи


JMP          BX;תƵַBX
CALL      AX                        ;õַAX
JMP        WORD PTR BP+TABLE      ;תƵַBP+TABLEָĴ洢Ԫ


JMP          2500H:3600H              ;תƵĶεַƫƵַָи
CALL      2600H:3800H          ;õĶεַƫƵַָи


JMP          DWORD PTRDI        ;תƵַDI,DI+1,DI+2,DI+3
  ;ָڴ浥Ԫ,ǰ2ֽΪƫ
  ;,2ֽΪεַ
CALL      DWORD PTRDI          ;õַDI,DI+1,DI+2,DI+3
  ;ָڴ浥Ԫ,ǰ2ֽΪƫ
  ;,2ֽΪεַ


MOV      EAX,32λ


MOV      DX,TABLEESI2


MOV      AX,TABLESI


IN    AL,32H;


IN    AL,DX;


MOV    EBX,ES:EDI;


  ǰ׺            Ѱַʽ      λ    0~3ֽ    1~2ֽ    0~2ֽ    0~4ֽ    04ֽ


MOV    dest,src; destsrc


MOV  EAX,EBX        ;EAX(EBX)(32λ˫)
MOV  AX,BX              ;AX(BX)  (16λ)
MOV  AL,BL              ;AL(BL)  (8λֽ)
MOV  EAX,25          ;EAX 25  (32λ)
MOV  EAX,500          ;EAXDS:500H Ԫ˫


XCHG    dest,src          ;destsrc


    TEST     MOV    AL,0FFH
             XCHG      AL,Semaphore
             AND      AL,AL            ;
JNZ          TEST                 ;鿴Semaphore,Ϊ0ʱ
    ;æʱȴ
    .
.
. ʹôӡ
MOV      AL,0
MOV      Semaphore,AL      ;ʹ,ÿб־


   IN            AL/AX/EAX,i8/DX            ;AL/AX/EAX(i8)/((DX))
OUT      i8/DX,AL/AX/EAX          ;i8/(DX)(AL)/(AX)/(EAX)


IN            AL,0FAH            ;Ӷ˿FAH8λAL
IN          EAX,0F4H          ;Ӷ˿F4HF5HF6HF7H32λ
IN          EAX,DX          ;DXָĶ˿32λEAX
OUT      DX,EAX          ;EAXDXָ32λ˿


LEA    r16/r32,mem


LEA            BX,SI                       ; BX(SI)
LEA          ECX,EDXݣ4ESIDOLLAR


LEA          BX,VARWORD


MOV      BX,OFFSET VARWORD


LDS  r16/r32,mem
LES  r16/r32,mem
LFS  r16/r32,mem
LGS  r16/r32,mem
LSS  r16/r32,mem


EXDWORD    DD    12345678H
LDS            SI,EXDWORD
LDSִָк,1234HDS,5678HSI


EXDWORD    DD    12345678H            ;ƫֵ
DW          0010H                      ;ѡ
LDS          ESI,EXDWORD


    LAHF
SAHF


XLAT      label
XLAT            ;AL DS:(((E)BX)+(AL))


SUB          AL,'0'             ;ALASCIIַתɱ
    ;XMIT_TABLEе
LDS          BX,TAB_POINT          ;ͷַָDS BX
XLAT      XMIT_TABLE          ;תӦļAL
OUT      42H,AL              ;42H˿ܺASCII
TAB_POINT            DD    XMIT_TABLE
        XMIT_TABLE      DB    '5791368024'


    PUSH      src
POP          dest


PUSH      AX
PUSH      EBX
PUSH      12340000H
PUSH      ECX
PUSH      FS
PUSH      GS


POP          AX
POP          M_ADD
POP          FS
POP          GS 


   PUSHA
            PUSHAD
            POPA
            POPAD


    PUSHF
PUSHFD
POPF
POPFD


    CBW
            CWD
CWDE
            CDQ


    MOVSX            dest,src
               MOVZX          dest,src


MOV              BL,92H        
MOVSX          AX,BL          ;AX=FF92H
MOVSX          ESI,BL          ;ESI=FFFFFF92H,BLݴչΪ32 
    ;λESI
MOVZX          EDI,AX      ;EDI=0000FF92H,16λAX0չ 
    ;32λEDI


BSWAP        r32


MOV            EAX,00112233H         ;EAX=00112233H
BSWAP          EAX                   ;EAX=33221100H


 CMPXCHG    dest,src


CMPXCHG    EDX,EBX        ;(EDX)=(EAX),EDX(EBX),
  ;ZF1,EAX(EDX),ZF0


CMPXCHG8B m64


CMPXCHG8B    QWORD PTR SI


ADD    dest,src          ;dest(dest)+(src)


ADD      AX,BX         ;AX(AX)+(BX)
ADD      EBX,ECX          ;EBX(EBX)+(ECX)
ADD      EXTMEM,AX      ;EXTMEM(EXTMEM)+(AX)
ADD      EXTMEM,23      ;EXTMEM(EXTMEM)+23


SUB    dest,src          ;dest(dest)-(src)


SUB      AX,BX                ;AX(AX)-(BX)
SUB          EAX,EBX                  ;EAX(EAX)-(EBX)
SUB          NUMBER,0FC981576H      ;NUMBER(NUMBER)-0FC981576H


ADC      dest,src          ;dest(dest)+(src)+(CF)


ADC      AL,4
ADC      AX,298
ADC      EBX,11223344H
ADC      NUMBER,78043810H


SBB      dest,src            ; dest(dest)-(src)-(CF)


SBB          AX,BX
SBB          EAX,EBX
SBB          ECX,0ABCD1234H


 XADD      dest,src  ;(dest)(src),dest(dest)+(src)


XADD    EAX,EBX            ;(EBX)(EAX)
                              ;EAX(EAX)+(EBX)


NEG    reg/mem          ;reg/mem0-(reg)/(mem)


MOV      AL,00000001B        ;AL=00000001B
NEG   AL        ;ALе,AL=11111111B
NEG      EBX           ;EBXе


CMP dest,src     ;(dest)-(src)


CMP      AL,5
JZ          ABC;            AL=5תABC,˳ִ

ABC:



          CMP            EXTMEM,61FAH
          CMP          EAX,0FFFF0000H


INC          reg/mem    ;reg/mem(reg)/(mem)+1
DEC      reg/mem              ;reg/mem(reg)/(mem)-1


INC    AL         ;AL(AL)+1
INC          EBX                      ;EBX(EBX)+1
INC          BYTE PTR MEMLOC        ;MEMLOC(BEMLOC)+1
DEC      BX                          ;BX(BX)-1
DEC      EAX                      ;EAX(EAX)-1


    MUL      reg/mem
IMUL      reg/mem


IMUL    dest,src


IMUL    dest,src,im


MOV        AL,NUMBER1
MUL          NUMBER2              ;˻AX
MOV          AX,NUMBER1
IMUL          NUMBER2              ;˻ĸ16λDX,ͬʱ
    ;EAXĸ16λ,16λAX
MOV        EAX,12345678H
IMUL          NUMBER              ;˻32λEDX,32λEAX
IMUL          EDX,ECX              ;EDXеݳECXе,
    ;EDX
IMUL          EDX,MEM_DWORD          ;EDXеݺڴ˫
    ;,EDX
IMUL    EDX,MEM_DWORD,20      ;洢˫ֳ20,EDX


    DIV            src
IDIV      src


MOV      AX,NUMBER
IDIV      DIVSR                       ;AL,AH
    MOV      DX,NUMBER_MSW
    MOV      AX,NUMBER_LSW
    IDIV      DIVSR                      ;ĸ16λDX,16 
  ;λAX,Ϊ16λ
  ;,AX,DX
MOV      EDX,NUMBER_MSB
MOV      EAX,NUMBER_LSB
IDIV      DIVSR                      ;32λEDX,32
  ;λEAX,Ϊ32λ;
  ;EAX,EDX


    DAA
DAS


    AAA
AAS
AAM
AAD


      AND      dest,src    ;dest(dest)(src)
OR          dest,src          ;dest(dest)(src)
XOR      dest,src          ;dest(dest)(src)
NOT      reg/mem          ;reg/mem(FFFF)FFFF-(reg)/(mem)
TEST      dest,src          ;(dest)(src)


NOT      EBX
AND      AX,0F0F0H
OR          AX,CX

TEST      AL,00010000B
JZ          ABC               ;ALλ4Ϊ0תABC˳ִ

ABC:



       SAL      reg/mem,1/CL/i8
SAR      reg/mem,1/CL/i8


MOV    CL,5
SAL          AX,CL
SAR          EBX,2


      SHL    reg/mem,1/CL/i8
SHR          reg/mem,1/CL/i8


SHR          WORD PTR TABLEBXݣDI,CL


ROL   reg/mem,1/CL/i8
ROR      reg/mem,1/CL/i8
RCL          reg/mem,1/CL/i8
RCR      reg/mem,1/CL/i8


     SHLD   reg/mem,reg,i8/CL
SHRD      reg/mem,reg,i8/CL


SHLD      TABLEEBX,EAX,5


    BT          dest,src
            BTC          dest,src
            BTR          dest,src 
BTS          dest,src


 MOV      CX4        
BT    BXݣCX          ;BXָĴ洢Ԫеλ4,λ
  ;4λ־
BITSA      DW 1234H,5678H
BITSB      DD 12345678H

BT        BITSA,4         ;(BITSA)=1234H,CF1
MOV      CX,22
BTC          BITSA,CX          ;(BITSA+2)=5638H,CF1
MOVZX    EAX,CX
BTS          BITSB,EAX          ;(BITSB)=12745678H,CF0


        BSF          reg,reg/mem
BSR          reg,reg/mem


BSR          EDXSTATUS_BIT


    IBTS
          XBTS


MOVSB/W/D


S_POINT    DD  S_ADDR    
D_POINT      DD  D_ADDR
S_ADDR          DB           ;Դ  

D_ADDR      DB          ;Ŀ

LDS          SI,S_POINT          ;ȫַָDS:SIֵ
LES          DI,D_POINT      ;ȫַָES:DIֵ
    CLD                         ;־0
MOV      CX,LENGTH      ;ôֵ
REP        MOVSB


CMPS B/W/D


SCAS B/W/D


LODS B/W/D


STOSB/W/D


OUTSB/W/D


INSB/W/D


    JMP            label
JMP          reg/m16   


JMP          NEAR PTR TABLEEBX      ;Ϊת
JMP          FAR PTR TABLEEBX          ;Ϊμת


JMP          WORD  PTRBX              ;Ϊת
JMP          DWORD  PTRBX              ;Ϊμת


JMP          DWORD  PTREBX              ;Ϊת
JMP          FWORD  PTREBX              ;Ϊμת


      DRVTBL    LABEL  WORD
  DW          DRV$INIT
  DW          MEDI$CHK
  
  DW       ENTRY
  
ENTRY 
  
  MOV      AX,SEG  DRVTBL
  MOV      DS,AX
  MOV      SI,NUMBER      ;NUMBERΪENTRYŵ
  JMP          NEAR  PTR  DRVTBLSI


MOV      AX,NUMBER
MOV      SI,OFFSET DRVTBL
ADD      SI,AX
JMP          WORD  PTRSI


MOV      BX,OFFSET ENTRY
JMP          BX


JA/JNBE    label    ;/ڵ,תƵlabelָĵַ
JAE/JNB  label  ;ڵ/,תƵlabelָĵַ
JB/JNAE  label  ;/ڵ,תƵlabelָĵַ
JBE/JNA  label  ;ڵ/,תƵlabelָĵַ 
JC  label  ;нλ,תƵlabelָĵַ
JE/JZ  label  ;/Ϊ0,תƵlabelָĵַ
JNC  label  ;޽λ,תƵlabelָĵַ
JNE/JNZ  label  ;/Ϊ0,תƵlabelָĵַ
JNP/JPO  label  ;ż/,תƵlabelָĵַ
JP/JPE  label  ;ż/ż,תƵlabelָĵַ


JG/JNLE          label      ;/Сڵ,תƵlabelָĵַ
JGE/JNL          label       ;ڵ/С,תƵlabelָĵַ
JL/JNGE          label       ;С/ڵ,תƵlabelָĵַ
JLE/JNG          label       ;Сڵ/,תƵlabelָĵַ
JNO          label       ;,תƵlabelָĵַ
JNS          label     ;0,תƵlabelָĵַ
JO          label     ;,תƵlabelָĵַ
JS          label     ;,תƵlabelָĵַ


JCXZ          label   ;CXеֵΪ0,תƵlabelָĵַ
JECXZ          label   ;ECXеֵΪ0,תƵlabelָĵַ


    LOOP        label
LOOPE          label
LOOPZ          label
LOOPNE          label
LOOPNZ          label


      MOV  CX,10
ABC:
          
      LOOP  ABC


    CALL  label  ; ֱӵ
            CALL      reg/mem      ; ӵ


PROCTABL  DD    SIP0
DD    SIP1
    
MOV      AX,SEG  PROCTABL
MOV      DS,AX
MOV      ESI,NENTRY    ;NENTRYĿӳŵ4,
  ;PROCTABLֽڵַ
CALL  FAR  PTR  PROCTABLESI


   RET
RET            m


 INT       i8
IRET
INTO


        STC
                CLC
                CMC
                STD
CLD
                STI
                CLI


 SETcc       r8/m8


SETNE    TEST BYTE            ;ZF־Ϊ1ʱ,TEST BYTEֽ
  ;Ϊ01H,Ϊ00H


ESC          i8,reg/mem


MOV   TR6,EAX           ;װԼĴTR6
MOV      EBX,CR3          ;CR3


RDMSR


WRMSR


LMSW      r16/m16


SMSW       r16/m16


LIDT  m16&32


SIDT        m16&32


LGDT  m16&32


SGDT  m16&32


LLDT          r16/m16


SLDT          r16/m16


LTR          r16/m16


STR          r16/m16


LAR          r16/r32,r16/m16


LSL           r16/r32,r16/m16


VERR      r16/m16


VERW      r16/m16


ARPL      r16/m16,r16


BOUND      r16/r32,m16&16/m32&32


ARRAY_LIMITS    DD    LOWER_LIMIT
                    DD UPPER_LIMIT
BOUND EDIARRAR_LIMITS


ENTER    i16,i8


LEAVE


 HLT


INVD


WBINVD


 INVLPG


    REP
REPZ/REPE
REPNZ/REPNE
SEG:            ;CS:,SS:,DS:,ES:,FS:,GS:
 LOCK


CPUID


RDTSC


RSM


    LEA            BX,TABLE
    MOV      AL,8
    XLAT


    MOV        AX,8057H
    PUSH      AX
    MOV      AX,0F79H
    PUSH      AX
    POP          BX
    POP          BX


    MOV        AL,89H
    ADD      AL,AL
    ADD     Al,9DH
    CMP      AL,0BCH
    SUB          AL,AL
    DEC      AL
    INC          AL


    MOV      AX,X
    MOV       DX,X+2
    ADD      AX,Y
    ADC       DX,Y+2
    ADD      AX,24
    ADC       DX,0
    SUB          AX,Z    
    SBB          DX,Z+2
    MOV       W,AX
    MOV      W+2,DX


    MOV      AX,X
IMUL      Y
    MOV      CX,AX
    MOV      BX,DX
    MOV      AX,Z
    CWD
    ADD      CX,AX
    ADC      BX,DX
    SUB          CX,540
    SBB          BX,0    
    MOV      AX,V
    CWD
    SUB          AX,CX
    SBB          DX,BX
    IDIV      X


MOV  AX,1470H
    AND	  AX,AX
    OR		  AX, AX
    XOR	  AX,AX
    NOT	  AX
    TEST	  AX,0F0F0H


MOV  SI,600H
    MOV	  DI,601H
    MOV	  AX,DS
    MOV	  ES,AX
    MOV	  CX,256
    STD
    REP		  MOVSB


CLD
    MOV	  AX,0FEFH
    MOV	  CX,5
    MOV	  BX,3000H
    MOV	  ES,BX
    MOV	  DI,2000H
    REP		  STOSW


MOV  CX,20
              		  MOV	  AX,0
              		  MOV	  SI,AX
    SUM_LOOP: 	  ADD 	  AX,ARRAYSI
  ADD	  SI,2
  LOOP 	  SUM_LOOP
              		  MOV	  TOTAL,AX


ADD  AL,BL
    DAA
    XCHG  AL,AH
    ADC   AL,BH
    DAA
    XCHG  AL,AH
    RET


4
: ӲָǷ  ,    ;ע


  αָǷ  ,;ע


            MOV    CX,56          ;ָ,2
DELAY:  NOP  ;ղָ,ûв,
  ;бDELAY
  LOOP   DELAY  ;ѭָ,DELAY˵תλ
BUFFER   DB  1,2,3,4,5,6,7  ;ݶαָ,п7
  ;ֽڵԪ,ֵΪ1~7,
  ;BUFFERʾǵ׵ַ


.MODEL	  SMALL	    ;Ĵ洢ģʽ,СͳһСģʽSMALL
    .STACK			  ;ջ
    .DATA 			  ;ݶ
    STRING    DB 'Hello,Everybody !',0DH,0AH,'$';ݶζҪ
  ;ʾַ
    .CODE 			  ;
    .STARTUP			  ;˵ʼλ,DSSS(1)
    MOV  DX,OFFSET STRING  ;ַָݶεƫƵַ
    MOV    AH,9
    INT     21H	  ;DOSܵʾϢ
.EXIT 0 	    ;,DOS(2)
    END	    ;(3)


STACK    SEGMENT STACK        ;ջSTACK
  DW      512 DUP(?)  ;ջεĴС1024B(512)ռ
STACK  ENDS  ;ջν
DATA  SEGMENT  ;ݶDATA
STRING  DB 'Hello,Everybody!',0DH,0AH,'$'
  ;ݶζҪʾַ
 DATA  ENDS  ;ݶν
 CODE  SEGMENT  'CODE'  ;CODE 
  ASSUME  CS:CODE,DS:DATA,SS:STACK
  ;ȷCSDSSSָ߼
 START:  MOV AX,DATA    ;ݶεĶεַDS
  MOV DS,AX
   MOV DX,OFFSET STRING   
  ;ùܵʾϢ
   MOV AH,9
  INT  21H
   MOV AX,4C00H   ;ϵͳܵ÷DOS
  INT  21H
CODE  ENDS   ;ν
END  START  ;,ͬʱʼλΪSTART


XYZ      SEGMENT  
      ...   ;
XYZ  ENDS


(1)      START:  MOV  AX,@DATA;ݶεĶεַDS
  MOV    DS,AX
(2)   MOV   AX,4C00H  ;DOS
  INT  21H
(3)   END  START  ;,ʼΪSTART


ML/c    LT401A.ASM


MASM    LT401A.ASM


LINK    LT401A.OBJ


LINK  /ѡOBJļбEXEļ,MAPļ,ļݣ;


ML  LT401A.ASM.


ML/ѡļб/LINKӲѡ


ML/Fl/Sg LT401A.ASM


LT401A.ASM	PAGE 11
        . MODEL SMALL
  . STACK
0000 			  . DATA
0000 48 65 6C	 6C 6F 2C 45 76 STRING DB 'Hello,Everybody !' ,0DH,0AH,'$'
  65 72 79 62 6F 64
  79 20 21 0D 0A24
0000			  . CODE
  . STARTUP
0000					       @STARTUP:
0000  3  BA R    MOV  DX,DGROUP
0003  2	  8E DA		  		  MOV	  DS,DX
0005	  2	  8C D3		  		  MOV	  BX,SS
0007	  2	  2B DA		  		  SUB		  BX,DX
0009	  2	  D1 E3		  		  SHL		  BX,001H
000B	  2	  D1 E3		  		  SHL		  BX,001H
000D	  2	  D1 E3		  		  SHL		  BX,001H
000F	  2	  D1 E3		  		  SHL		  BX,001H
0011		  1	  FA			  		  CLI
0012	  2	  8E D2		  		  MOV	  SS,DX
0014	  2	  03 E3		  		  ADD	  SP,BX
0016	  2	  FB			  		  STI
0017	  3	  BA 0000 R			  MOV	  DX,OFFSET STRING
001A	  2	  B4 09				  MOV	  AH,9
001C	  2	  CD 21				  INT		  21H
            . EXIT 0
001E	  3	  B8 4C00		  		  MOV	  AX04C00H
0021	  2	  CD 21		  		  INT		  021H
END
LT401A. ASMSYMBOLS 2 -1
SEGMENTS AND GROUPS
      NAME				SIZE    LENGTH  ALIGN  COMBINE     CLASS
    DGROUP  ......... 	  GROUP
    _DATA  ...........	  16 BIT       0014		  WORD   PUBLIC  'DATA'
    STACK  ...........	  16 BIT       0400		  PARA	  STACK  'STACK'
    _TEXT  ..........		  16 BIT       0023		  WORD  PUBLIC  'CODE'
     SYMBOLS:..
      NAMETYPE      VALUE    ATTR
@CODESIZE  .............	  NUMBER	  0000H
@DATASIZE  .............	  NUMBER	  0000H
@INTERFACE  ............	  NUMBER 	  0000H
@MODEL  ................	  NUMBER  	  0002H
@STARTUP  ..............	  LNEAR 	  0000 		  _TEXT
@CODE  .................	  TEXT            		  _TEXT
@DATA  ................. 	  TEXT      				  DGROUP 
    @FARDATA?..............	  TEXT					    FAR_BSS
    @FARDATA................	  TEXT					    FAR_DATA
    @STACK  ................	  TEXT    DGROUP
STRING  .................	  BYTE  0000  _DATA
    0 Warnings
    0 Errors


ML/Fm  LT401A.ASM


Start    Stop    Length      Name    Class
00000H  00022H  00023H  _TEXTCODE
00024H  00037H  00014H  _DATADATA
00040H  0043FH  00400H  STACKSTACK
Origin  Group
0002:0      DGROUP
Address    Publics by Name
Address    Publics by Value
Program entry point at 0000:0000


DEBUG LT401A.EXE


14C4: 0000 BAC614    MOV    DX,14C6
14C4: 0003 8EDA  MOV  DS,DX
14C4: 0005 8CD3  MOV  BX,SS
14C4: 0007 2BDA  SUB  BX,DX
14C4: 0009 D1E3  SHL  BX,1
14C4: 000B D1E3  SHL  BX,1
14C4: 000D D1E3  SHL  BX,1
14C4: 000F D1E3  SHL  BX,1
14C4: 0011 FA  CLI
14C4: 0012 8ED2  MOV  SS,DX
14C4: 0014 03E3  ADD  SP,BX
14C4: 0016 FB  STI
14C4: 0017 BA0400  MOV  DX,0004
14C4: 001A B409  MOV  AH,09
14C4: 001C CD21  INT  21
14C4: 001E B8004C  MOV  AX,4C00
14C4: 0021 CD21  INT  21


D 14C6: 0
14C6: 0000 4C CD 21 00 48 65 6C 6C6F 2C 45 76 65 72 79 62  L.!.Hello,Everyb
14C6: 0010 6F 64 79 20 21 0D0A 24-FE 06 44 04 06 57 1E 56  ody!..$..D..W.V


.RADIX    n


  EQU  ֵʽ
  EQU  <ַ> 


DOSWRITECHAR    EQU      2
CALLDOS  EQU  <INT 21H>
CARRIAGERETURN  EQU  13


MOV    AH,2      ;MOV AH,DOSWRITECHAR  
MOV  DL,13  ;MOV DL,CARRIAGERETURN
INT  21H  ;CALLDOS


=ֵʽ 


X=7        ;ͬX  EQU 7ȷ
X=X+5  ;X  EQU X+5Ǵ


MOV    AX,3  4+5        ;ȼMOV AX,17


OR  AL,03H AND 45H        ;ȼOR AL,01H


 SHL/SHRλ


MOV    AL,0101B  SHL(22)    ;ȼMOV	AL,01010000B


MOV    BX,((PORT LT 5)    AND 20) OR ((PORT GE 5) AND 30)
;PORT<5ʱ,ΪMOV BX,20
;,ΪMOV BX,30


MOV    AH,HIGH  8765H    ;ȼMOV AH,87H


DD_VALUE  EQU 0FFFF1234H          ;һų
MOV    AX,LOWWORD DD_VALUE  ;ȼMOV AX,1234H


۱  αָ    ֵ


ظ  DUP(ظ)


DATA    SEGMENT          ;ݶ
  X  DB  'a',  -5
  DB  2      DUP(100),?
  Y  DB  'ABC'
DATA  ENDS


MOV    AL,X      ;˴Xʾĵ1,AL'a'
DEC  X+1  ;XΪʼĵ2ݼ1,ʳΪ -6
MOV  Y,AL  ;YַΪ'aBC'


DATA        SEGMENT              ;ݶ
COUNT  DW  8000H ,?,'AB'
MAXINT  EQU  64H
NUMBER  DW  MAXINT
ARRAY  DW  MAXINT DUP(0)
DATA  ENDS


WNUM  EQU 5678H
COUNT  DW 20H


MOV    AX,BX+SI+WNUM    ; MOV AX,BX+SI+5678H
MOV  AX,COUNT   ;MOV AX,0010H
MOV  AX,SI+COUNT  ; MOV AX,COUNTSI 
  ; MOV AX,SI+10H
LEA  BX,COUNT  ;LEA BX,0010H
MOV  BX,OFFSET  COUNT  ; MOV BX,0010H


VARDD      DD 0,?,12345678H
FARPOINT  DD 00400078H


    .MODEL SMALL
    .STACK
    .DATA
    BVAR   DB16
    WVAR	  DW		  43
    DVAR	  DD		  4294967295   ;=232 -1=FFFFFFFFH
    QVAR	  DQ		  ?
    		  DB		  1,2,3,4,5
    TVAR	  DT		  2345
    ABC	  DB		  'A','B','C'
    MSG	  DB		  'HELLO',13,10,'$'
    BBUF	  DB		  12  DUP('MONTH')
    DBU	  DD		  25  DUP(?)
    CALLDOS  EQU  <INT 21H>
    .CODE
    .STARTUP							          ;DS
    MOV  BL,BVAR
    MOV	  AX,WORD  PTR  DVAR0  ;ȡ˫ֵDX.AX
    MOV	  DX,WORD  PTR  DVAR2
    MOV	  DX,OFFSET MSG
    MOV	  AH,09H
    CALLDOS
    .EXIT 0 							  ;زϵͳ
END								  ;


    .MODEL SMALL
    .STACK
    .DATA
    SOURCE    DB 33H,34H,35H,36H    ; 4ַ
    TARGET  DB 80 DUP(?)    			  ;ŷ临ݿռ4  20=80
    .CODE
    .STARTUP
        MOV   AX,DS
    	  MOV  ES,AX  ;DATAμݶǸӶ
    	  CLD
    	  MOV	  SI,OFFSET SOURCE
    	  MOV	  DI,OFFSET TARGET
    	  MOV	  CX,80
REP		  MOVSB				  ;
                 			  ;4ֽں,SIָTARGETΪԴ
                 			  ;Ŀǽŵ
    	  MOV	  SI,0 		  ;ʾ
    	  MOV	  BX,OFFSET TARGET
AGAIN:  MOV DL,BX+SI	  ;MOV DL,TARGETSIݿʡǰһ
    	  MOV	  AH,2
    	  INT		  21H
    	  INC		  SI
    	  CMP	  SI,80
    	  JB		  AGAIN
    .EXIT 0
    END


ORG


ORG 100h      ;100hݻ
ORG $+10  ;ʹƫƵַ10,10ֽڿռ


ARRAY      DB      12,34,56
LEN  EQU  $-ARRAY


EVEN


ALIGN  n 


DATA      SEGMENT  ;ζ
DATA01		  DB 1,2,3	  ;DATA01ƫƵַΪ0000H
EVEN   ;ȼALIGN 2
DATA02  DW 5  ;DATA02ƫƵַΪ0004H
ALIGN 4
DATA03  DD 6  ;DATA03ƫƵַΪ0008H
ORG  $+10H
DATA04  DB  'ABC'  ;DATA04ƫƵַΪ001CH
DATA  ENDS


OFFSET/


SEG/


MOV    AX,SEG ARRAY
MOV	  DS,AX
MOV	  BX,OFFSET ARRAY      ;ȼLEA BX,ARRAY


MOV  CL,ARRAY+4    ;ЧMOV  CL,ARRAY4,4ʾ4ֽڵԪ


 PTR /


MOV    AL,BYTE PTR W_VAR    ;W_VARһֱ,BYTE PTRʹΪһֽڱ
JMP  FAR PTR N_LABEL  ;N_LABELһ,FAR PTRʹΪμת


THIS


B_VAR      EQU THIS BYTE      ;ֽڷʱB_VAR,W_VARĵַͬ
W_VAR  DW 10 DUP(0)  ;ַʱW_VAR
F _JUMP  EQU  THIS FAR  ;F_ JUMPΪμת(F_JUMP LABEL FAR)
N_JUMP:  MOV  AX,W_VSR  ;N_JUMPΪڽת,ָͬһָ


SHORT


JMP      SHORT  N_JUMP


TYPE  /


MOV    AX,TYPE W_VAR    ;ΪMOV AX,2
MOV  AX,TYPE N_JUMP	  ;ΪMOV AX,0FF02H(NEAR)


.MODEL SMALL
.STACK
.DATA 
V_BYTE    EQU    THIS BYTE      ;V_BYTEֽ͵ı,
  ;V_WORDַͬ
    V_WORD  DW  3332H,3735H  ;V_WORD͵ı
TARGET  DW   5 DUP (20H)  ;ݿռ2  5=10ֽ
CRLF  DB  0DH,0AH,'$'
    FLAG  DB  0
    N_POINT  DW OFFSET S_LABEL  ;ȡñS_LABELƫƵַ
.CODE
.STARTUP
  MOV  AL,BYTE PTR V_WORD  ;PTRıW_ WORD
        ;,ALĴͲƥ
  DEC  AL
  MOV  V_BYTEAL  ;V_WORDĵһֽڲ,ԭ
  ;32H,31H
N_LABEL:  CMP  FLAG,1
  JZ  S_LABEL  ;FLAGԪΪ1,ת
  INC  FLAG
  JMP  SHORT  N_LABEL;ת
S_ LABEL:  CMP  FLAG,2
  JZ  NEXT;FLAGԪΪ2ת
  INC  FLAG
  JMP  N_POINT;ڵĴ洢Ѱַ,ת
;ƵS_LABEL
NEXT:  MOV  AX,TYPE V_WORD;ΪMOV AX,2
  MOV  CX,LENGTHOF TARGET;ΪMOV CX,5
  MOV  SI,OFFSET  TARGET
W_AGAIN:  MOV  SI,AX;ֵԪ
  INC  SI;SIָ2
  INC  SI
  LOOP  W_AGAIN;ѭ
  MOV  CX,SIZEOF TARGET;ΪMOV CX,0AH
  MOV  AL,'?'
  MOV  DI,OFFSET TARGET
B_AGAIN:  MOV  DI,AL ;ֽڵԪ
  INC  DI;DIָ1
  LOOP  B_AGAIN;ѭ
  MOV  DX,OFFSET V_WORD;ʾ:1357??????????
  MOV  AH,9
  INT  21H
  .EXIT 0
  END


    .MODEL   SMALL      ;Ĵ洢ģʽ(һSMALL)
    .STACK  ;ջ
    .DATA  ;ݶ
    		  ;ݶ
    .CODE	  ;
    .STARTUP  ;ʼ,DS,SS
    		  ;
    .EXIT 0  ;,DOS
    	      ;ӳ
END      ;


MODEL洢ģʽ,ͣݣ,ϵͳͣݣ,ջѡ


.STACK ۴С


.DATA
.DATA ?


.CODE ۶


.STARTUP


MOV    DX,DGROUP      ;DGROUPʾݶĶεַ
MOV	  DS,DX  ;DS
MOV	  BX,SS
SUB		  BX,DX
SHL		  BX,1
SHL		  BX,1
SHL		  BX,1
SHL		  BX.1
CLI	  ;ж
MOV	  SS,DX  ;SS=DS,SMALLģʽĹ涨
ADD	  SP,BX  ;ƶSSεַ,SPҲҪӦ
STI  ;ж


START:    MOV    AX,@DATA    ;@DATAʾݶεĶεַ
MOV    DS,AX  ;DS


 .EXIT۷


MOV    AX,4C00H
INT  21H


END۱ţ


.MODEL TINY                                ;΢ģʽ
.CODE  ;ֻһ,ûݶκͶջ
.STARTUP  ;ЧORG 100H,Զ
  MOV  DX,OFFSET STRING  ;ʾϢ
  MOV  AH,9
  INT  21H
  MOV  AH,01H  ;ȴ
  INT  21H
  MOV  AH,02H  ;
  MOV  DL,07H
  INT  21H
.EXIT 0
STRING DB 'PRESS ANY KEY TO CONTINUE !$'  ;ݰڲͻĵط
END 


STACK    SEGMENT STACK            ;ջSTACK
  ...  ;ջεĴС
STACK  ENDS  ;ջν
DATA  SEGMENT   ;ݶDATA
  ...  ;
DATA   ENDS	  ;ݶν
CODE  SEGMENT	  'CODE'  ;CODE
ASSUME CS:CODE,DS:DATA,SS:STACK  ;ȷCS/DS/SSָ߼
START:  MOV  AX,DATA   ;ݶεĶεַDS
  MOV  DS,AX
  ...  ;
  MOV  AX,4C00H   ;DOS
  INT  21H
  ...  ;ӳ
CODE  ENDS    ;ν
  END  START  ;,ʼλΪSTART


      SEGMENT ۶λ ݣϣ ۶֣ ''
...      ;
      ENDS


ASSUME  μĴ:,μĴ:,...


CODE  SEGMENT
  ASSUME CS:CODE,DS:DATA,SS:STACK,ES:DATA
  MOV	  AX,DATA
  MOV	  DS,AX
  MOV	  ES,AX
  MOV	  AX,STACK
  MOV	  SS,AX
  
CODE    ENDS


  GROUP  ۣ


STACKSEG      SEGMENT  STACK                  
  DB 256 DUP(?)
STACKSEG	  ENDS
DATA1		  SEGMENT  WORD PUBLIC 'CONST'	  ;ݶ
CONST1		  DW    100
DATA1 		  ENDS
DATA2  SEGMENT WORD PUBLIC 'VARS'   ;ݶ
VAR1   DW  ?
DATA2  ENDS
DATAGROUP  GROUP  DATA1,DATA2  ;
CODESEG	  SEGMENT PARA PUBLIC 'CODE'
ASSUME	  CS:CODESEG,DS:DATAGROUP,SS:STACKSEG
START:	  MOV AX,DATAGROUP
  MOV	  DS,AX    ;DSֵԸѰַ
  MOV	  AX,CONST1     ;AX=100
  MOV	  VAR1,AX      ;VAR1=100
  MOV	  AX,OFFSET VAR1  ;AX=2
  MOV	  AX,OFFSET DATA1  ;AX=2
  MOV	  AX,OFFSET DATA2    ;AX=4
ASSUME	  DS:DATA2
  MOV	  AX,DATA2
  MOV	  DS,AX
  MOV	  AX,VAR1   ;AX=100
  MOV	  AX,OFFSET VAR1  ;AX=2
  MOV	  AX,4C00H
  INT  21H
CODESEG	  ENDS
  END	  START


.SEG


.DOSSEG 


.ALPHA 


DSEG    SEGMENT  WORD  PUBLIC 'DATA'      
  ORG	  100H;趨ջʼƫƵַ
  DW		  200		  DUP(?)
TOPSP  EQU  THIS  WORD;ջָ
ARRAY  DW  100  DUP(5868H)
DSEG	  ENDS
CSEG	  SEGMENT  'CODE'
ASSUME CS:CSEG,DS:DSEG,SS:DSEG            ;DSEGݶǶջ
START:  MOV	  AX,DSEG
  MOV	  DS,AX
  MOV	  SS,AX  ;ݶջξͬĶεַ
  MOV	  SP,OFFSET TOPSP
  MOV	  CX,100
  XOR	  SI,SI
AGAIN:	  PUSH	  ARRAYSI
  INC  SI
  INC  SI
  LOOP  AGAIN
  MOV  AH,4CH
  INT  21H
CSEG  ENDS
  END  START


DGROUP    GROUP	_DATA,_BSS,STACK
ASSUME	  CS:_TEXT,DS:DGROUP,SS:DGROUP


ṹ    STRUCT
  	                ;ݶ
ṹ  ENDS


STUDENT    STRUCT            
  SID  DW  ?
  SNAME  DB  'ABCDEFGH'
  MATH  DB  0
  ENGLISH  DB  0
STUDENT  ENDS


  ṹ  <ֶγֵ>


STU1    STUDENT    <1,'ZHANG',85,90>      
STU2	  STUDENT	  <2,'WANG',,>
  STUDENT	  100 DUP(< >)				  ;Ԥ100ṹռ


MOV  STU1.MATH,95;ִָ,MATHֵΪ95


   	.MODEL  SMALL
  	.STACK	  256
   	.DATA
   	PERSON		  STRUCT
    NUMBER	        DW	0
    PNAME		        DB	''  		  ;8ַ
    SEX 		        DB	0
    BIRTHDAY  	        DB	 'MM/DD/YYYY'
   	PERSON      ENDS
  	ARRAY  	  PERSON 100 DUP(<>)		  ;ṹԤ100հ׽ṹ
   	.CODE
.STARTUP
MOV  BX,OFFSET ARRAY
    		  MOV 	  AX,1
     		  SUB		  SI,SI
       		  MOV	  CX,LENGTH ARRAY  	  ;CXṹĸ(100)
      		  MOV	  DX,TYPE ARRAY     	  ;DXṹռֽ
AGAIN:  MOV	  BX+SI.PERSON.NUMBER,AX         ;ûбʱҪýṹֶ
  INC		  AX
  ADD	  SI,DX
  LOOP	  AGAIN
    .EXIT 0
END


¼RECORDλΣ,λΡ


λ: λ=ʽ


PERSON    RECORD YEAR:4, SEX:1=0, MARRIAGE:1=1


    ¼ ¼ <γֵ>


ZHANG  PERSON    <1000B,1,0>        ;ֵֽΪ:00100010B=22H
WANG  PERSON  <1001B,0,0>  ;ֵֽΪ:00100100B=24H


MOV  AL,ZHANG    ;AL22H


MOV  BL,YEAR    ;BL2


MOV  CL,WIDTH PERSON    ;CL6


MOV  DL,MASK SEX    ;DL=00000010B=02H


  MACROβα
  궨
ENDM


MAINBEGIN    MACRO         ;;һΪMAINBEGINĺ,޲
  MOV  AX,@DATA  ;;궨
  MOV  DS,AX
ENDM	  ;;궨


MAINEND    MACRO RETNUM        ;;βRETNUM
  MOV	  AL,RETNUM  ;;궨ʹõĲ
  MOV	  AH,4CH
  INT		  21H
ENDM


DISPMSG    MACRO MESSAGE
  LEA  DX,MESSAGE          ;;ҲMOV DX,OFFSET MESSAGE
  MOV	  AH,09H
  INT		  21H
ENDM


ʵα


MAINBEGIN    MACRO             
  MOV	  AX,@DATA    
  MOV	  DS,AX
ENDM          
MAINEND		  MACRO RETNUM    
  MOV	  AL,RETNUM    
  MOV	  AH,4CH
  INT	  21H
  ENDM
DISPMSG	      MACRO MESSAGE
  LEA	  DX,MESSAGE	;;ҲMOV  DX,OFFSET MESSAGE
  MOV	  AH,09H
  INT 	  21H
  ENDM
     .MODEL	  SMALL
     .STACK
      .DATA
      STRING		  DB 'Hello,Everybody !',0DH,0AH,'$'
      .CODE
  START:	  MAINBEGIN;,DS
  DISPMSG	  STRING;,ʾSTRINGַ
  MAINEND 0  ;,DOS
   END	  START


START:    MAINBEGIN            ;ָ
1  MOV  AX,@DATA  ;չ
1  MOV  DS,AX
  DISPMSG  STRING  ;ָ
1  LEA  DX,STRING  ;չ
1  MOV  AH,09H
    1  INT  21H   
   MAINEND  0  ;ָ
1  MOV  AL,0  ;չ
1  MOV  AH,4CH
1  INT  21H
  END  START


DOSINT21  MACRO FUNCTION          ;;궨   
  MOV  AH,FUNCTION
  INT  21H
  ENDM
DISPMSG  MACRO MESSAGE  ;;кõĺ궨
  MOV  DX,OFFSET MESSAGE
  DOSINT21 9  ;;
  ENDM


DISPMSG   MSG                ;
1    MOV  DX,OFFSET MSG	  ;չ(һ)
1    DOSINT21	  9
2   MOV  AH,9  ;չ(ڶ)
2   INT  21H


SHLEXT  MACRO SHLOPRAND,SHLNUM
        PUSH  CX
  MOV	  CL,SHLNUM	  ;;SHLNUMʾλ
  SHL	  SHLOPRAND,CL 	  ;;SHLOPRANDʾλĲ
  POP	  CX
  ENDM


SHLEXT    AX,6


1    PUSH  CX
1  MOV	  CL,06
1  SHL	  AX,CL
1   POP   CX


SHIFT  MACRO SOPRAND,SNUM,SOPCODE
  PUSH	  CX
  MOV	  CL,SNUM
  S&SOPCODE& SOPRAND,CL
  POP  CX
  ENDM


SHIFT  AX,6,HL


SHROT  MACRO  SROPRAND,SRNUM,SROPCODE
  PUSH	  CX
  MOV	  CL,SRNUM
  SROPCODE SROPRAND,CL
  POP 	  CX
  ENDM


DSTRING  MACRO	STRING
DB	'& STRING&',0DH,0AH,'$'
  ENDM


DSTRING  <THIS IS  A  EXAMPLE.>


1  DB  'THIS  IS  A  EXAMPLE.',0DH,0AH,'$'


DSTRING  <0 <NUMBER <10 >       ; 
1 DB'0<NUMBER<10',0DH,0AH,'$',    ;չ


DSTRING  (1024-1)            ;
1    DB '1023',0DH,0AH,'$'       ;չ


LOCALб


ABSOL      MACRO OPRD
LOCAL  NEXT
  CMP 	  OPRD,0
  JGE	  NEXT
  NEG  OPRD
NEXT:
  ENDM  ;;αָҪռһ


    ABSOL		    WORD PTR BX
    ABSOL		  BX


1    CMP    WORD PTR BX,0
1  JGE	  ??0000
1      NEG	  WORD PTR BX
1      ??0000:
1      CMP	  BX,0
1      JGE	  ??0001
1      NEG	  BX
1      ??0001:


PURGE


EXITM


.MODEL SMALL
.STACK
.DATA
X  DB 8CH
Y  DB 64H
Z  DB ?
.CODE
.STARTUP                
  MOV	  AL,X		  ;AL8CH
  ADD	  AL,Y		  ;AL8CH+64H
  MOV	  AH,00H  	  ;AH00H
  ADC	  AH,00H 	  ;λAH
  MOV	  BL,2    	  ;2BL
  DIV		  BL      	  ;AXBL,̡AL,AH
  MOV	  Z,AL   	  ;ZԪ
    .EXIT 0
END


    .MODEL  SMALL
    .STACK
    .DATA
    QVAR	  DQ 1234567887654321H
    .CODE
    .STARTUP
    MOV	  AL,BYTE PTR QVAR6
    MOV	  BYTE PTR QVAR7,AL
    MOV	  AL,BYTE PTR QVAR5
    MOV	  BYTE PTR QVAR6,AL
    MOV	  AL,BYTE PTR QVAR4
    MOV	  BYTE PTR QVAR5,AL
    MOV	  AL,BYTE PTR QVAR3
    MOV	  BYTE PTR QVAR4,AL
    MOV	  AL,BYTE PTR QVAR2
    MOV	  BYTE PTR QVAR3,AL
    MOV	  AL,BYTE PTR QVAR1
    MOV	  BYTE PTR QVAR2,AL
    MOV	  AL,BYTE PTR QVAR0
    MOV	  BYTE PTR QVAR1,AL
    MOV	  BYTE PTR QVAR0,0
    .EXIT 0
    END


          CMP  AX,0        
  JGE  NONNEG   ;֧:AX0
  NEG  AX   ;,Ϊ,Ҫִз֧
NONNEG:  MOV	  RESULT,AX   ;,Ϊ,


          CMP  AX,0        
  JL	  YESNEG  ;֧:AX <0
  JMP	  NONENG  ;,Ϊ,Ҫ,ת򱣴
YESNEG:   NEG AX         ;,Ϊ,Ҫ
NONNEG:  MOV RESULT,AX  ;


        SHL    BX,1        ;BXλCF־
  JC  ONE    ;CF=1,λΪ1,ת
  MOV  DL,'0'  ;CF=0,λΪ0;DL'0'
  JMP  TWO  ;һҪһ֧
ONE:  MOV	  DL,'1'  ;DL'1'
TWO:	  MOV	  AH,2
  INT  21H  ;ʾ


        MOV    DL,'0'      ;DL'0'
  SHL  BX,1  ;BXλCF־
  JNC  TWO  ;CF=0,λΪ0,ת
  MOV	  DL,'1'  ;CF=1,λΪ1,DL'1'
TWO:   MOV  AH,2
  INT  21H  ;ʾ


.MODEL  SMALL
.STACK
.DATA
_A    DB  ?
_B    DB  ?
_C    DB  ?
TAG  DB  ?
.CODE
.STARTUP                
  MOV  AL,_B
  IMUL  AL
  MOV  BX,AX  ;BXΪB2
  MOV  AL,_A
  IMUL   _C
  MOV  CX,4
  IMUL  CX  ;AXΪ4AC(ĿDXЧֵ)
  CMP  BX,AX  ;Ƚ϶ߴС
  JGE	  YES  ;?
  MOV  TAG,0  ;һ֧:,TAG0
  JMP  DONE  ;ڶ֧
YES:  MOV  TAG,1  ;ڶ֧:,TAG1
DONE:  .EXIT 0
  END


OR      AH,AH          ;ЧCMP 	AH,0
JZ	  FUNCTION0  ;AH=0,תFUNCTION0
DEC	  AH      ;ЧCMP AH,1
JZ  FUNCTIONL  ;AH=1,תFUNCTIONL
DEC  AH  ;ЧCMP AH,2
JZ  FUNCTION2  ;AH=2,תFUNCTION2


    .MODEL	SMALL
    .STACK
    .DATA
MSG    DB	'Input number(1~8):',0dh,0ah,'$'
MSG1	  DB	'Chapter 1:Fundamentals of Assembly Language',0dh,0ah,'$'
MSG2	  DB	'Chapter 2:80X86 Instruction Set',0dh,0ah,'$'
MSG3	  DB 	'Chapter 3:Statements of Assembly Language',0dh,0ah,'$'
MSG4	  DB 	'Chapter 4:Basic Assembly Language Programming',0dh,0ah,'$'
MSG5	  DB 	'Chapter5:Advanced Assembly Language Programming',0dh,0ah,'$'
MSG6	  DB	'Chapter 6:32bit lnstructions and Programming',0dh,0ah,'$'
MSG7	  DB	'Chapter 7:Mixed Programming with C/C++',0dh,0ah,'$'
MSG8	  DB	'Chapter 8:FP Instructions and Programming',0dh,0ah,'$'
TABLE	  DW DISP1,DISP2,DISP3,DISP4,DISP5,DISP6,DISP7,DISP8
                                    ;ȡøŵƫƵַ
      .CODE
      .STARTUP
      START1:	  MOV	  DX,OFFSET MSG	;ʾ
              	  MOV	  AH,9
              	  INT		  21H
              	  MOV	  AH,1         	;ȴ
              	  INT		  21H
              	  CMP	  AL,'1'         	;<1 ?
              	  JB		  START1
              	  CMP 	  AL,'8'      	;>8 ?
              	  JA 		  START1
              	  AND	  AX,000FH    	;ASCIIת
              	  DEC	  AX
              	  SHL		  AX,1         	;ЧADD AX,AX
             	  MOV	  BX,AX
             	  JMP		  TABLEBX		;()ת:IPTABLE+BX
  START2: 	  MOV	  AH,9
  INT  21H
      .EXIT 0
  ;
  DISP1:  MOV	  DX,OFFSET MSG1    ;1
  JMP 	  START2
  DISP2:  MOV	  DX,OFFSET MSG2    ;2
  JMP 	  START2
  DISP3:  MOV   DX,OFFSET MSG3    ;3
  JMP 	  START2
  DISP4:  MOV 	  DX,OFFSET MSG4    ;4
  JMP  START2
  DISP5:  MOV 	  DX,OFFSET MSG5    ;5
  JMP  START2
  DISP6:  MOV 	  DX,OFFSET MSG6    ;6
  JMP 	  START2
  DISP7:  MOV	  DX,OFFSET MSG7    ;7
  JMP   START2
  DISP8:  MOV	  DX,OFFSET MSG8    ;8
  JMP 	  START2
  END


.MODEL SMALL                
.STACK
.DATA
  SUM	  DW ?
.CODE
.STARTUP
  XOR	  AX,AX   	  ;AX0
  MOV	  CX,100
AGAIN:	  ADD	  AX,CX   	  ;100,99,,2,1ۼ
  LOOP	  AGAIN
  MOV	  SUM,AX 	  ;ۼӺָԪ
    .EXIT 0
  END


.MODEL SMALL
.STACK
.DATA
WORDX  DW 56
BYTEY   DB ?
.CODE
.STARTUP                      
  MOV	  AX,WORDX	  ;ĿAX
  MOV	  CX,16    ;ѭóֵ
  MOV  DL,-1  ;λóֵ
AGAIN:  INC  DL
  TEST  AX,1
  ROR  AX,1  ;ѭָӰZF
  LOOPE  AGAIN  ;CX<>0ZF=1(λΪ0),ѭ
  JE  NOTFOUND
  MOV  BYTEY,DL
  JMP  DONE
NOTFOUND:  MOV  BYTEY,-1  ;ZF=1,Ŀ16λΪ0
DONE:  .EXIT 0
  END


.MODEL	SMALL
.STACK
.DATA
STRING    DB 'HELLO,EVERYBODY!',0  ;һַ
.CODE
.STARTUP
  MOV 	  BX,OFFSET STRING
AGAIN:  	  MOV	  AL,BX  ;ȡһַ
  OR	  AL,AL  ;ǷΪβ0
  JZ  DONE  ;,˳ѭ
  CMP  AL,'A'  ;ǷΪдA~Z
  JB  NEXT
  CMP   AL,'Z'
  JA   NEXT
  OR   AL,20H  ;,תΪСдĸ(ʹD5=1)
  MOV  BX,AL   ;Աԭλ
NEXT:  INC 	  BX
  JMP  AGAIN  ;ѭ
DONE:  .EXIT 0
  END


.MODEL SMALL
.STACK
.DATA
ARRAY  DB 56H,23H,37H,78H,0FFH,0,12H,99H,64H,0B0H
  DB 78H,80H,23H,1,4,0FH,2AH,46H,32H,42H
COUNT	  EQU    ($-ARRAY)/TYPE ARRAY  ;ݸ
.CODE
.STARTUP                      
  MOV	  CX,COUNT  ;CXԪظ
  DEC	  CX   ;Ԫظ1Ϊѭ
OUTLP:  MOV   DX,CX   ;DXѭ
  MOV  BX,OFFSET ARRAY
INLP:  MOV  AL,BX  ;ȡǰһԪ
  CMP  AL,BX+1  ;һԪرȽ
  JNA  NEXT  ;ǰһںһԪ,򲻽н
  XCHG  AL,BX+1  ;,н
  MOV	  BX,AL
NEXT:	  INC  BX  ;һԪ
  DEC  DX
  JNZ  INLP  ;ѭβ
  LOOP  OUTLP  ;ѭβ
.EXIT 0
  END


    .MODEL SMALL
.STACK
.DATA
STRING  DB  'LET US HAVE A TRY !','$'   ;һַ
.CODE
.STARTUP
        MOV    SI,OFFSET STRING      
OUTLP:  CMP	  BYTE PTR SI,'$'  ;ѭ,жϺѭ
  JZ 	  DONE  ;Ϊ0
AGAIN:  CMP  BYTE PTR SI,' '  ;Ƿǿո
  JNZ	  NEXT  ;ǿոѭ
  MOV 	  DI,SI		  ;ǿո,޳ո֧÷֧ѭ
INLP:	  INC 	  DI
  MOV  	  AL,DI  	  ;ǰһλ
  MOV 	  DI-1,AL
  CMP	  BYTE PTRDI,'$'	  ;ѭ,ѭж
  JNZ 	  INLP
  JMP	  AGAIN   ;жǷΪո
NEXT:  INC	  SI  ;Ժַжϴ
  JMP   OUTLP
DONE:     .EXIT 0	  ;
  END


   PROC NEAR/FAR
  
  ENDP


DPCRLF    PROC              ;ĬԵĹ
  PUSH	  AX   ;Ĵ;˳ѹջ
  PUSH	  DX
  MOV	  DL,0DH   ;سַΪ0DH
  MOV  AH,2
  INT  21H
  MOV   DL,0AH    ;пַΪ0AH
  MOV  AH,2
  INT  21H
  POP  DX    ;ָĴ:򵯳ջ
  POP	  AX
  RET  ;ӳ򷵻
DPCRLF      ENDP     ;̽


ALDISP    PROC            ;ʵALݵʾ
  PUSH	  AX   ;ʹAX,CXDX
  PUSH   CX
  PUSH  DX
  PUSH  AX  ;ݴAX
  MOV  DL,AL  ;תALĸ4λ
  MOV	  CL,4
  SHR  DL,CL
  OR  DL,30H  ;AL4λ'3'
  CMP  DL,39H
  JBE  AL DISP1
  ADD	  DL,7   ;0AH~0FH,ASCII뻹Ҫ7
ALDISP1:  MOV 	  AH,2     ;ʾ
  INT   21H
  POP	  DX   ;ָԭAXֵDX
  AND 	  DL,0FH     ;תALĵ4λ
  OR   DL,30H
  CMP   DL,39H
  JBE  ALDISP2
  ADD 	  DL,7
ALDISP2:   MOV 	  AH,2      ;ʾ
  INT 	  21H
  POP 	  DX
  POP 	  CX
  POP	  AX
  RET   ;̷
ALDISP  ENDP


.MODEL    SMALL
.STACK
.DATA
  ARRAY	  DB 56H,23H,37H,78H,0FFH,0,12H,99H,64H,0B0H
  DB 78H,80H,23H,1,4,0FH,2AH,46H,32H,42H
  COUNT  EQU    ($-ARRAY)/TYPE ARRAY  ;ݸ
.CODE
.STARTUP                          
  MOV	  CX,COUNT 	  ;CXԪظ
  DEC	  CX      ;Ԫظ1Ϊѭ
OUTLP:  MOV  DX,CX   ;DXѭ
  MOV  BX,OFFSET ARRAY
INLP:  MOV  AL,BX   ;ȡǰһԪ
  CMP  AL,BX+1   ;һԪرȽ
  JNA   NEXT     ;ǰһںһԪ,򲻽н
  XCHG   AL,BX+1    ;,н
  MOV   BX,AL
NEXT:  INC  BX      ;һԪ
  DEC   DX
  JNZ   INLP     ;ѭβ
  LOOP  OUTLP   ;ѭ
  MOV  BX,OFFSET ARRAY  ;óοʼ
  MOV  CX,COUNT
DISPLP:  MOV  AL,BX
  CALL  ALDISP  ;ʾ
  MOV  DL,','    ;ʾһ,Էָ
  MOV  AH,2
  INT  21H
  INC  BX
  LOOP  DISPLP    ;óν
  .EXIT 0
  ... 	  ;̶,ͬ4.29Դ
  END 


.MODEL SMALL
.STACK
.DATA
COUNT EQU  10      ;Ԫظ
ARRAY DB 12H,25H,0F0H,0A3H,3,68H,71H,0CAH,0FFH,90H	        ;
RESULT DB ?                ;У
.CODE
.STARTUP                    ;ڲ(DSĶεַ)
  MOV  BX,OFFSET ARRAY  ;BXƫƵַ
  MOV  CX,COUNT  ;CXԪظ
  CALL  CHECKSUMA   ;͹
  MOV  RESULT,AL  ;ڲ
.EXIT 0
;ֽУ͵ͨù
;ڲ:DS:BX=Ķεַ:ƫƵַ,CX=Ԫظ
;ڲ:AL=У
;˵:AX/BX/CX,ӰĴ
CHECKSUMA  PROC
  XOR  AL,AL  ;ۼ0
SUMA:  ADD   AL,BX  ;
  INC  BX    ;ָһֽ
  LOOP  SUMA
  RET
CHECKSUMA  ENDP
END


.MODEL SMALL
.STACK
.DATA
COUNT EQU    10                    ;Ԫظ
ARRAY DB 12H,25H,0F0H,0A3H,3,68H,71H,0CAH,0FFH,90H
  ;
RESULT DB ?    ;У
.CODE
.STARTUP           ;DSĶεַ
  CALL  CHECKSUMB   ;͹
.EXIT 0
; ֽУ
; ڲ:ARRAY=,COUNT=Ԫظ
;           RESULT=Уʹŵı
CHECKSUMB  PROC
  PUSH  AX
  PUSH  BX
  PUSH  CX
  XOR   AL,AL  ;ۼ0
  MOV  BX,OFFSET ARRAY  ;BXƫƵַ
  MOV  CX,COUNT     ;CXԪظ
SUMB:  ADD  AL,BX    ;
  INC  BX
  LOOP  SUMB
  MOV  RESULT,AL    ;У
  POP  CX
  POP  BX
  POP  AX
    RET
CHECKSUMB  ENDP
  END


.MODEL SMALL
.STACK
.DATA
COUNT    EQU 10                                        ;Ԫظ
ARRAY DB 12H,25H,0F0H,0A3H,3,68H,71H,0CAH,0FFH,90H      ;
RESULT DB ?   ;У
.CODE
.STARTUP                        
  MOV  AX,OFFSET ARRAY	  ;ڲ
    PUSH   AX  ;ѹƫƵַ
   MOV  AX,COUNT
  PUSH  AX  ;ѹԪظ
  CALL  CHECKSUMC  ;͹
  ADD   SP,4  ;ƽջ
  MOV   RESULT,AL  ;У
  .EXIT 0
;ֽУ͵Ľ
;ڲ:ڶջѹƫƵַԪظ
;ڲ:AL=У
CHECKSUMC  PROC                
  PUSH  BP
   MOV  BP,SP  ;BPָǰջ,ȡڲ
  PUSH  BX  ;ʹõBXCXĴ
   PUSH  CX
  MOV  BX,BP+6  ;BXSS:BP+6(ƫƵַ)
  MOV  CX,BP+4  ;CXSS:BP+4(Ԫظ)
  XOR  AL,AL  ;ۼ0
  SUMC:  ADD  AL,BX  ;:AL(AL) + DS:BX
  INC  BX
  LOOP  SUMC
  POP  CX  ;ָĴ
  POP  BX
  POP  BP
  RET
CHECKSUMC  ENDP
  END


ALDISP      PROC                        ;ʾALе2λʮ
  PUSH  AX  ;ڲ
  PUSH  CX
  PUSH  AX     ;ݴ
  MOV  CL,4
  SHR  AL,CL  ;תALĸ4λ
  CALL  HTOASC     ;ӳ(Ƕ)
  POP  AX  ;תALĵ4λ
  CALL  HTOASC    ;ӳ(Ƕ)
  POP  CX   
  POP  AX
  RET        ;ӳ򷵻
ALDISP     ENDP
;
HTOASC      PROC  ;AL4λ1λʮתΪASCII
  PUSH  AX     ;ڲ
  PUSH  BX
  PUSH  DX
  MOV  BX,OFFSET ASCII   ;BXָASCII
  AND  AL,0FH       ;ȡ1λʮ
  XLAT  CS:ASCII     ;:ALCS:BX+AL,ע
  ;ڴCS
  MOV  DL,AL  ;ʾ
  MOV  AH,2
  INT  21H
  POP  DX
  POP  BX
  POP  AX
  RET
;ӳ
ASCII  DB 30H,31H,32H,33H,34H.35H,36H,37H,38H,39H
        DB 41H,42H,43H,44H,45H,46H
HTOASC  ENDP


.MODEL	SMALL
.STACK
.DATA
N        DW      3            
RESULT  DW  ?
.CODE
.STARTUP
  MOV  BX,N
  PUSH  BX
  CALLFACT
  POPRESULT
.EXIT 0
FACT  PROC;N!Ľ
  PUSH  AX ;ڲ:ѹN
  PUSH  BP;ڲ:N!
  MOV  BP,SP
  MOV   AX,BP+6
  CMP  AX,0
  JNE  FACT1
  INC   AX
  JMP   FACT2
FACT1: DEC     AX
  PUSH  AX
  CALL  FACT
  POP  AX
  MUL  WORD PTRBP+6
FACT2:   MOV  BP+6,AX
  POP   BP
  POP   AX
  RET
FACT    ENDP
END


.MODEL SMALL
.STACK
.DATA
COUNT	=10
ARRAY DW COUNT DUP(0)            
.CODE
.STARTUP
  MOV  CX,COUNT
  MOV  BX,OFFSET ARRAY
AGAIN:  CALL  READ  ;ӳ,һ
  MOV   BX,AX   ;ڲŵݻ
  INC  BX
  INC  BX
  CALL  DPCRLF  ;ӳ,سԱһ
  ;
  LOOP  AGAIN
.EXIT 0
;
READ  PROC  ;зʮͨӳ:READ
  PUSH  BX  ;ڲ:AX=ʾĶֵ
  PUSH  CX   ;˵:"-",ݷΧ-32768~+32767
  PUSH  DX
  XOR  BX,BX  ;BX
  XOR  CX,CX  ;CXΪ־,0Ϊ,1Ϊ
  MOV  AH,1  ;һַ
  INT  21H
  CMP  AL,'+'  ;"+",ַ
  JZ  READ1
  CMP  AL,'-'    ;"-", -1־
  JNZ  READ2
  MOV  CX,-1
READ1:  MOV  AH,1  ;ַ
  INT  21H
READ2:  CMP  AL,'0'  ;0~9ַ֮,ݽ
  JB  READ3
  CMP  AL,'9'
  JA  READ3
  SUB  AL,30H  ;0~9ַ֮,תΪ
  ;λָ,ʵֵ10,BXBX 10
  SHL  BX,1
  MOV  DX,BX
  SHL  BX,1
  SHL  BX,1
  ADD  BX,DX
  MOV  AH,0
  ADD  BX,AX  ;ֵ10,ֵ
  JMP  READ1   ;ַ
READ3:  CMP  CX,0   ;Ǹ,
  JZ   READ4
  NEG  BX
READ4:    MOV  AX,BX  ;óڲ
  POP  DX
  POP  CX
  POP  BX
  RET    ;ӳ򷵻
READ  ENDP
DPCRLF  PROC    ;ʹسеӳ
  PUSH  AX
  PUSH  DX
  MOV  AH,2
  MOV  DL,0DH
  INT   21H
  MOV  AH,2
  MOV  DL,0AH
  INT  21H
  POP  DX
  POP   AX
  RET
DPCRLF  ENDP
END


.MODEL SMALL
.STACK
.DATA
ARRAY DW 1234,-1234,0,1,-1,32767,-32768,5678,-5678,9000
COUNT=($-ARRAY)/2
WTEMP DW	?
.CODE
.STARTUP
  MOV  CX,COUNT
  MOV  BX,OFFSET ARRAY
AGAIN:  MOV  AX,BX
  MOV  WTEMP,AX  ;ڲŵ
  CALL  WRITE  ;ӳ,ʾһ
  INC  BX
  INC  BX
  CALL  DPCRLF  ;سԱʾһ
  LOOP  AGAIN
.EXIT 0
;
WRITE  PROC  ;ʾзʮͨӳ:WRITE
  PUSH  AX  ;ڲ:WTEMP
  PUSH  BX
  PUSH  DX
  MOV  AX,WTEMP  ;ȡʾ
  TEST  AX,AX     ;ж㡢
  JNZ  WRITE1
  MOV  DL,'0'  ;,ʾ"0"˳
  MOV  AH,2
  INT  21H
  JMP  WRITE5
WRITE1:  JNS  WRITE2  ;Ǹ,ʾ"-"
  MOV   BX,AX  ;AXݴBX
  MOV  DL,'-'
  MOV  AH,2
  INT  21H
  MOV  AX,BX
  NEG   AX   ;(ֵ)
WRITE2:  MOV  BX,10
  PUSH   BX    ;10ѹջ,Ϊ˳־
WRITE3:  CMP  AX,0  ;()Ϊ,תʾ
  JZ  WRITE4
  SUB   DX,DX  ;չDX.AX
  DIV  BX  ;ݳ10:DX.AX10
  ADD  DL,30H   ;(0~9)תΪASCII
  PUSH  DX    ;ݸλȵλλѹջ
  JMP  WRITE3
WRITE4:  POP  DX    ;ݸλȸλλջ
  CMP  DL,10  ;ǽ־10,˳
  JE  WRITE5
  MOV  AH,2  ;ʾ
  INT   21H
  JMP  WRITE4
WRITE5:  POP  	DX
  POP  BX
  POP   AX
  RET     ;ӳ򷵻
WRITE  ENDP
    ;ͬ4.24


.MODEL SMALL
.STACK
.DATA
ARRAY  DW 1234,-1234,0,1,-1,32767,-32768,5678,-5678,9000
COUNT  =  ($-ARRAY)/2
WMED    DW ?   ;ƽֵ
.CODE
.STARTUP
  MOV  AX,COUNT
  PUSH   AX   ;ѹݸ
  MOV   AX,OFFSET ARRAY
  PUSH   AX    ;ѹݻƫƵַ
  CALL   MEAN  ;ӳ,ƽֵ
  ADD   SP,4   ;ƽջ
  MOV   WMED,AX    ;ڲ(δ)
.EXIT 0
MEAN    PROC   ;16λзƽֵӳ:MEAN
  PUSH  BP  ;ڲ:˳ѹݸݻƫƵַ
  MOV   BP,SP  ;ڲ:AX =ƽֵ
  PUSH   BX   ;Ĵ
  PUSH  CX
  PUSH   DX
  PUSH  SI
  PUSH  DI
  MOV   BX,BP+4    ;ӶջȡƫƵַBX
  MOV   CX,BP+6   ;ջеݸCX(μͼ4.7)
  XOR   SI,SI  ;SI͵ĵ16λֵ
  MOV   DI,SI  ;DI͵ĸ16λֵ
MEAN1:  MOV   AX,BX   ;ȡһݡAX
  CWD       ;չDX
  ADD   SI,AX   ;͵16λ
  ADC  DI,DX  ;͸16λ
  INC   BX    ;ָһ
  INC   BX
  LOOP   MEAN1     ;ѭ
  MOV   AX,SI    ;ۼӺת浽DX.AX
  MOV   DX,DI
  MOV   CX,BP+6  ;ݸCX
  IDIV   CX  ;з,ƽֵAX(DX)
  POP  DI    ;ָĴ
  POP   SI
  POP   DX
  POP   CX
  POP   BX
  POP   BP
  RET                         
MEAN  ENDP                                 
  END


.IFʽ         
  ֧1
.ELSEIFʽ    

  ֧2
  
.ELSE      
 
  ֧N
.ENDIF  


.IF        AX<0          ;ȼ.IF SIGN?
  NEG    AX  ;,
.ENDIF
    MOV  RESULTAX


.IF        AX==5
  MOV  BX,AX
  MOV  AX,0
.ELSE
  DEC  AX
.ENDIF


.IF        AX == 5
   CMP  AX,05H
  JNE  @C0001
  MOV  BX,AX
  MOV  AX,0    
.ELSE
    JMP  @C0003    
@C0001:  DEC  	AX    
.ENDIF
@C0003:


MUL    CL      ;AXAL  CL(255)
IMUL  CL  ;AXAL  CL(-1)


.MODEL SMALL                   
.STACK
.DATA
_A  SBYTE  ?
_B  SBYTE  ?
_C  SBYTE  ?
TAG  BYTE  ?
.CODE
.STARTUP
  MOV  AL,_B
  IMUL   AL
  MOV   BX,AX  ;BXΪB2
  MOV  AL,_A
  IMUL    _C
  MOV   CX,4
  IMUL   CX   ;AXΪ4AC
.IF  SWORD  PTR BX >=AX   ;Ƚ϶ߴС
  MOV  TAG,1   ;һ֧:,TAG1
.ELSE
  MOV   TAG,0   ;ڶ֧:,TAG0
.ENDIF
.EXIT 0
  END


.WHILEʽ
  ѭ
.ENDW  


    XOR    AX,AX          ;AX0
  MOV  CX,100
.WHILE  CX!=0
  ADD  AX,CX  ;100,99,,2,1ۼ
  DEC  CX
.ENDW
  MOV  SUM,AX  ;ۼӺָԪ


.REPEAT            ;ظִѭ
  ѭ
.UNTILʽ  ;ֱΪ


.REPEAT    
  ADD  AX,CX
  DEC  CX
.UNTIL CX==0


.REPEAT                ;ظִѭ
  ѭ
.UNTILCXZ ʽ  ;CXCX-1,ֱCX=0Ϊ


.REPEAT       
  ADD  AX,CX
.UNTILCXZ


.MODEL    SMALL      
.STACK
.DATA
  ARRAY  SWORD  100 DUP(?)
  RESULT  SWORD  ?
.CODE
.STARTUP      
  MOV  CX,100
  XOR  AX,AX
  LEA  BX,ARRAY
.REPEAT   
  .IF  SWORD PTRBX >=0
  ADD  AX,BX
  .ELSE
  .BREAK
  .ENDIF
  INC  BX
  INC  BX
.UNTILCXZ
  MOV  RESULT,AX
.EXIT 0
  END


  PROC    ۵þݣͣݣ÷Χݣ<ʼ>
  USESĴбݣ,:ݣͣݣݡ
  LOCAL
     ;
  ENDP


LOCAL۸ݣ:ͣݣ,


PROTO۵þ ͣ ,:ͣݣ


INVOKE    ,,


.MODEL  SMALL                                          
CHECKSUMD  PROTO  C,:WORD,:WORD  ;
.STACK 256
.DATA
COUNT  EQU:  10  ;Ԫظ
ARRAY DB 12H,25H,0F0H,0A3H,3,68H,71H,0CAH,0FFH,90H  ;
RESULT  DB ?  ;У
.CODE
.STARTUP
INVOKE CHECKSUMD,COUNT,OFFSET ARRAY  ;ù
  MOV   RESULT,AL  ;У
.EXIT 0
;ֽУ͵Ĺ
;ڲ;COUNTP =Ԫظ,ARRAYP =ƫƵַ
;ڲ:AL=У
CHECKSUMD PROC C USES BX CX,COUNTP:WORD,ARRAYP:WORD
  MOV   BX,ARRAYP  ;BXƫƵַ
  MOV  CX,COUNTP  ;CXԪظ
  XOR   AL,AL
SUMD:  ADD   AL,BX  ;:ALAL+DS:BX
  INC  BX
  LOOP  SUMD
  RET
CHECKSUMD ENDP
  END


INVOKE    CHECKSUMD,COUNT,OFFSET ARRAY
    MOV  AX,WORD PTR OFFSET ARRAY
    PUSH   AX
    MOV   AX,+000AH
    PUSH  AX
    CALL   CHECKSUMD
    ADD   SP,04H
    ;ⲿԴͬ
CHECKSUMD PROC C USES BX CX,COUNTP:WORD,ARRAYP:WORD
    PUSH  BP    ;ʼ
    MOV  BP,SP
    PUSH   BX    ;BXCX
    PUSH  CX
  MOV   BX,ARRAYP  ;ARRAYP=BP+6(ƫƵַ)
  MOV   CX,COUNTP  ;COUNTP=BP+4(Ԫظ)
  XOR   AL,AL
  SUMD  ADD AL,BX
  INC   BX
  LOOP   SUMD
  RET
    POP  CX     ;β
    POP   BX
    POP   BP
    RET  0000H
CHECKSUMC    ENDP


MYDATA    SEGMENT
  ORG  100H
  VARW  DW  1234H,5678H
  VARB     DB   3,4
  AGLIN 4
  VARD    DD   12345678H
  EVEN
  BUFF     DB   10 DUP(?)
  MESS  DB  'HELLO'
BEGIN:   MOV  AX,OFFSET VARB+OFFSET MESS
  MOV  AX,TYPE BUFF+TYPE MESS+TYPE VARD
  MOV   AX,SIZE OF VARW+SIZE OF BUFF+SIZE OF MESS
  MOV   AX,LENTH OF VARW+LENTH OF VARD
  MOV   AX,LENTH OF BUFF+SIZE OF VARW
  MOV   AX,TYPE BEGIN
  MOV   AX,OFFSET BEGIN


LEDTABLE  DB 0C0H,0FGH,0A4H,0B0H,99H,92H,82H,0F8H
  DB 80H,90H,88H,83H,0CGH,0C1H,86H,8EH


CRAZY PROC      
  PUSH  AX
  XOR  AX,AX
  XOR  DX,DX
AGAIN:  ADD  AX,BX
  ADC   DX,0
  INC   BX
  INC  BX
  LOOP  AGAIN
  RET
    ENDP   CRAZY


;ӳ: ASCIIʾ2λʮתΪӦ
;ڲ: DH =ʮλASCII룬DL=λASCII
;ڲ: AL=ӦĶ


.IF    X==5  &&  (AX!=BX)
  INC  AX
.ENDIF


.IF    X==5 || (AX!=BX)
  INC  AX
.ENDIF


.WHILE     AX    !=10
  MOV  BX,AX
  INC  BX
  INC   BX
  INC  AX
.ENDW


.REPEAT    
  MOV  BX,AX
  INC  BX
  INC   BX
  INC   AX
.UNTIL    AX==10


DIF      MACRO X,Y
  MOV AX,X
  SUB AX,Y
  ENDM
ABSDIF MACRO V1,V2,V3
  LOCAL  CONT
  PUSH  AX
  DIF  V1,V2
  CMP   AX,0
  JGE   CONT
  NEG   AX
CONT:   MOV   V3,AX
  POP   AX
  ENDM


5
MOV  AH,02H
MOV  DH,3
MOV  DL,14
INT   10H


WRITINGPIXEL  PROC    NEAR
  PUSH      AX
  MOV       AH,0CH
  INT    10H
  POP  AX
WRITINGPIXEL  ENDP


MYDATA      SEGMENT
  PARAMETERS    DB 100
  DB ?
  DB 100 DUP(?)
  MESSAGE  DB "What is your name?"
  DB "$"
MYDATA  ENDS
MYSTACK  SEGMENT  STACK
  DB 100 DUP(?)
MYSTACK  ENDS
MYCODE  SEGMENT
ASSUME  CS: MYCODE,  DS: MYDATA,  SS: MYSTACK
START  PROC    FAR
  PUSH  DS
  MOV  AX,0
  PUSH  AX
  MOV  AX,MYDATA
  MOV  DS,AX
DISP:  MOV  DX,OFFSET MESSEGE
  MOV  AH,09H
  INT  21H
KEY:  MOV  DX,OFFSET PARAMETERS
  MOV  AH,10
  INT  21H
  RET
START  ENDP
MYCODE  ENDS
END  START


HANDLE CreateFile(
  LPCTSTR lpFileName,DWORD dwDesiredAccess,
  DWORDdwShareMode,LPSECURITY_ATTRIBUTES lpsecurityAttributes,
  DWORD dwCreationDisposition, DWORD dwFlagsAndAttrlbutrs,
  HADEL  hTemplateFile)


HANDLE CreateFile(LPCTSTR lpFileName,DWORD dwDesiredAccess,
DWORD dwShareMode,LPSECURITY_ATTRIBUTES lpsecurityAttributes,
DWORD  dwCreationDisposition,DWORD dwFlagsAndAttributrs,
HADEL hTemplateFile)


HFILE_lopen(LPCSTR lpPathName,int iReadWrite)


HFILE_lcreat(LPCSTR lpPathName,int iAttribute)


DWORD SetFilePoint(HANDLE hFile,LONG iDistanceToMove,
PLONG lpDistanceToMoveHigh,DWORD dwMoveMethod)


LONG_llseek(HFILE hFile,LONG LOffset,int LOrigin)


BOOL ReadFile (HANDLE hFile,LPVOID ipBuffer,
DWORD nNumberOfByteToRead,
LPDWORD lpNumberOfBytesRead,
LPOVERLAPPED lpOverlapped)
BOOL WriteFile (HANDLE hFile,LPCVOID lpBuffer, 
DWORD nNumderOfBytesToWrite,
LPDWORD lpNumberOfBytesWrite,
LPOVERLAPPED lpOverlapped)


UINT_lread(HFILE hFile,LPVOID lpBuffer,UINT uBytes)
UINT_ lwrite(HFILE hFile,LPCSTR lpBuffer,UINT uBytes)


BOOL CloseHandle(HANDLE hObject)
HFILE_lclose(HFILE hFile)


HGLOBAL GlobalAlloc(Uint uFlags,DWORD dwBytes)


LPVOID GlobalLock(HGLOBAL hMem)


BOOL LoadFile(char FileName)
  {
          HFILE  hf;                                        // ļ
          long  hFilesize;                                // ļ
          HGLOBAL  hFhandle;                          // ڴ
          LPVOID  hFileBuffer;                          // ڴ滺ָ
             // ļļ,ļ,ʧܷ
          if((hf=_lopen(Filename,OF_READ))==HFILE_ERROR)
             {
            MessageBox(hWnd,"File not found!","Error Message",
                   MB_OK|MB_ICONEXCLAMATION);
            return FALSE;
            }
            // ļ,ļǰļ
          _lread(hf,(LPCSTR)&hFilesize,sizeof(DWORD));  // õļ
          hFilesize-=1000;                                // ȼȥ1000ֽ
             // ϵͳļСڴ,ܷ,ʧܷ
          if((hFhandle=GlobalAllocGHND,hFilesize==NULL)
             {
            MessageBox(hWnd,"Error alloc memory!","Error Message",
MB_OK|MB_ICONEXCLAMATION);
            _lclose(hf);
            return FALSE;
            }
          hFileBuffer=GlobalLock(hFhandle);       // õڴ׵ַ
          _llseek(hf,(LONG)1000,FILE_BEGIN);   // ָӿͷƶ1000B
          _lread(hf,(LPCSTR)hFileBuffer,hFilesize);  // ļ
          _lclose(hf);                                // رļ
          returnTRUE;                                // 
        }


    // ʼ
    // Ĺܶ
    int PASCAL WinMain(HANDLE,HANDLE,LPSTR,int);      // 
    LRESULT CALLBACK MainWndProc(HWND,UINT,WPARAM,LPARAM) ;
  // ڹ
    BOOL LoadFile(HWND hWnd,char UmpFilieName);            // ļװ
    // ȫֱ
    BITMAPFILEHEADER  bf;
    BITMAPINFOHEADER  bi;
    HPALETTE hPalette=NULL;
    HBITMAP  hBitmap=NULL;
    HGLOBAL  hImSData=NULL;
    HWND    hWnd;
    CHAR    BmpFileName;
    // ʼ
    int PASCAL WinMain(HANDLE hInstance,HANDLE hPrevInstance,
LPSTR lpszCmdLine,int nCmdShow)
    {
     // Ϣʹͱ
     MSG    msg;
     WNDCLASS  wndclass;
     // 鵱ǰǷ,δ,ô
if(!hPrevInstance)
{
      wndclass.style=CS_HREDRAW | CS_VREDRAW;           // ôڷ
      wndclass.1pfnWndProc =MainWndProc;                      // ôڹ
      wndclass.cbClsExtra =0;
      wndclass.cbWndExtra =0;
      wndclass.hInstance =hInstance;                             // ôھ
      wndclass.hIcon =LoadIcon(NULL,IDI_APPLICATION);     // ôͼ
      wndclass.hCursor =LoadCursor(NULL,IDC_ARROW);      // ôڹ
      wndclass.hbrBackground =GetStockObject(WHITE_BRUSH);  // ôڱ
      wndclass.1pszMenuname ="ͼļʾ";                   // ò˵
      wndclass.lpszClassName ="ͼϵͳ";                       // 
     }
     // עᴰ,עʧ򷵻
     if!RegisterClass(wndclass))
     return FALSE:
     // 
    hWnd =CreateWindow("ͼϵͳ","򿪲ʾBMPͼļ",
WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,
CW_USEDEFAULT,CW_USEDEFAULT,
CW_USEDEFAULT,NULL,NULL,hInstance,NULL);
    // ʧ,
    if(!hWnd)
    return FALSE;
    // ʹڿɼ
    showWindow(hWnd,SW_SHOWMAXIMIZED);
    // ʾ
    UpdateWindow(hWnd);
    // ȴϢѭ
    while(GetMessage(&msg,NULL,0,0))
  {
  // õһϢ,ȶϢз
  TranslateMessage(&msg);
  // ȻϢ,Ϣ
  DispatchMessage(&msg);
  }
    return msg.wParam;
    }
    // ǴڵϢ
LRESULT CALLBACK MainWndProc(HWND hWnd,UINT message,
WPARAM wParam,LPARAM iParam)
    // 豸ͻͼ
    Static  HDC  Hdc, hMemDC;
    PAINTSTRUCT    ps;
    switch(message)
  {
  // Ϣǻͼ
  case WM_PAINT:
  }
    // Ϊͼ׼ָĴ
    hDC =BeginPaint(hWnd,&ps);
    // ڿʾλͼļ
    if(hBitmap)
     {
      // ڴ潨һݵڴ豸
      hMemDC =CreateCompatibleDC(hDC);
      // õ˵ɫ
      if(hPalette)
  {
  // Ϊ豸ڴ豸ѡʵĵɫ
  SelectPalette(hDC,hPalette,FALSE);
  SelectPalette(hMemDC,hPalette,FALSE);
  // ӳ䵽ϵͳɫ
  RealizePalette(hDC);
  }
      // λͼ͵ڴ豸
      SelectObject(hMemDC,hBitmap);
      // ʾλͼ
      BitBlt(hDC,0,0,bi.biWidth,bi.biHeight,hMemDC,0,0,SRCCOPY);
      // ʾ,ɾڴ豸
      DeleteDC (hMemDC);
     }
    // ڵĻƹ
    EndPaint(hWnd,&ps);
    break;
    }
    // Ϣǳ
    case WM_DESTROY:
       // ɾλͼڴ
       if(hBitmap!=NULL)
       DeleteObject(hBitmap);
       // ɾɫڴ
       if(hPalette!=NULL)
       DeleteObject(hPalette);
       // ͷλͼռõڴ
       if(hImgData!=NULL)
       {
         GlobalUnlock(hImgData);
         GlobalFree(hImgData);
        }
       // ˳Ϣ󷵻
       PostQuitMessage(0);
       return 0;
   // Ϣ
case WM_COMMAND:
switch(wParam)
{
      // װλͼ
      case IDM_LOADBMP:
      // ͷԭλͼɫ
      if(hBitmap!=NULL)
      {
        DeleteObject(hBitmap);
        hBitmap=NULL;
       }
       if(hPalette!=NULL)
       {
        DeleteObjeet(hPalette);
        hPalette=NULL;
       }
      // ͷԭλͼռõڴռ
      if(hlmgData!=NULL)
      {
        GlobalUnlock(hImgData);
        GlobalFree(hImgData);
        hImgData=NULL;
       }
      // װµλͼļ
      if (LoadBmpFile(hWnd,BmpFileName))
      // װسɹػ
      InvalidateRect(hWnd,NULL,TRUE);
      break;
      // ˳,ϵͳ˳Ϣ
      case IDM_EXIT:
        SendMessagc(hWnd,WM_DESTROY,0,0L)  ;
      break;
      }
      break;
      }
    Return DefWindowProc(hWnd,message,wParam,1Param)  ;
    }
    // λͼļװش
    BOOL LoadBmpFile(HWND hWnd,char BmpFileName)
    {
      HFILE                   hf;
      LPBITMAPINFOHEADER    1pImgData;
      LOGPALETTE              pPal;
      LPRGBQUAD               lpRGB;
      HPALETTE                 hPrevPalette;
      HDC                       hDc;
      HLOCAL                   hPal;
      DWORD                   LineBytes;
      DWORD                   ImgSize;
      DWORD                   NumColors;
      DWORD                   i;
      // ͼļ
      if( (hf=_lopen(BmpFileName,OF_READ)) == HFILE_ERROR) 
        {
          MessageBox(hWnd,BmpFileName,"ļ",
          MB_OK|MB_ICONEXCLAMATION) ;
          return FALSE;
        }
       // λͼļͷ
       _lread(hf,(LPSTR)&bf,sizeof(BITMAPFILEHEADER)) ;
       _1read(hf,(LPSTR)&bi,sizeof(BITMAPINFOHEADER)) ;
       // õͼĳߴ
       LineBytes = (DWORD)WIDTHBYTES(bi.biWidth,bi.BitCount);
       ImgSize =(DWORD) LineBytesbi.biHeight;
       // õͼĲɫ,ɫģʽõɫ
      if(bi.biClrused!=0)
            NumColors =(DWORD)bi.ClrUsed;
       // õɫ
       else
          switch(bi.biBitCount)
          {
           case 1:
              NumColor=2;                            // ɫģʽ
              break;
           case 4:
              NumColors=16;                          // 16ɫ
              break;
           case 8:
              NumColors=256;                         // 256ɫ
              break;
           case 24:
              NumColors=0;                          // ɫģʽ
              break;
       // ǷǷɫ
           default:
           MessageBox(hWnd,"ͼɫǷ!","Ϣ",
MB_OK | MB_ICONEXCLAMATION);
       // رļ,˳
       _lclose(hf);
       return FALSE;
      }
   // ɫ,ʵ,˳
if(bf.bfOffBits!=(DWORD)(NumColorssizeof(RGBQUAD)
               +sizeof(BITMAPFILEHEADER)
               +sizeof(BITMAPINPINFOHEADER)))
      {
        MessageBox(hWnd,"ͼɫǷ!","Ϣ",
  MB_OK,MB_ICONEXCLAMATION);
         _lclose(hf);
         return  FALSE;
       }
   // ͼĴСڴ
   bf.bfSize=sizeof (BITMAPFILEHEADER)+sizeof (BITMAPINFOHEADER)
+NumColorsslzeof(RGBQUAD)+ImgSize;
   // ڴʧ˳
   if((hImgData=GlobalAlloc(GHND,(DWORD)(sizeof(BITMAPINFOHEADER)
                        +NumColorssizeof(RGBQUAD)+ImgSize)))==NULL)
    {
    MessageBox(hWnd,"ڴ! ","Ϣ",
    MB_OK| MB_ICONEXCLAMATION);
      _lclose(hf);
      return FALSE;
     }
    // ȡڴĵַ
    LpImgData=(LPBITMAPINFOHEADER)GlobalLock(hImgData);
    // ļָ붨λͼݵĿͷ
    _llseek(hf,sizeof(BITMAPFILEHEADER),SEEK_SET);
    // ͼ
    _hread(hf,(char )lpImgData,(long)sizeof(BITMAPINFOHEADER)
            +(long) NumColorssizeof(RGBQUAD)+ImgSize);
    // رļ
    _lclose(hf);
    // õɫ
    if(NumColors!=0)
    {
      // Ƚһʱɫ
        hPal=LocalAlloc(LHND,sizeof(LOGPALETTE) 
+NumColorssizeof(PALETTEENTRY));
        pPal =(LOGPALETTE ) LocalLock(hPal)  ;
        pPal>palNumEntries =(WORD)NumColors;
        pPal>palVersion =0x300;
  lpRGB=(LPRGBQUAD)((LPSTR)lpImgData+(DWORD)sizeof(BITMAPINFOHEADER));
       // ɫ˳
        for(i=0;i<NumColors;i++)
  {
               pPal >palPalEntryi.peRed =1pRGB >rgbRed;
               pPal >palPalEntryi.peGreen=lpRGB >rgbGreen;
               pPal >palPalEhtryi.peBlue=lpRGB >rgbBlue;
               pPal >palPalEntryi.peFlags=(BYTE)0;
               lpRGB++;
             }
       // ϵͳɫ,ɾʱɫ
       hPalette =CreatePalette(pPal);
       LocalUnlock(hPal);
       LocalFree(hPal);
      }
    // ԭ豸ĵɫ,ͼεĵɫ
    hDc=GetDC(hWnd);
    if(hPalette)
       {
       hPrevPalette =SelectPalette(hDc,hPalette,FALSE);
       RealizePalette(hDc);
       }
       // ļеؽΪλͼ
       hBitmap=CreateDIBitmap(hDc,(LPBITMAPINFOHEADER)lpImgData,
                            (LONG)CBM_INIT,(LPSTR)lplmgData
                            +sizeof(BITMAPINFOHEADER) 
                            +NumColorssizeof(RGBQUAD),
                            (LPBITMAPINFO)lpImgData,DIB_RGB_COLORS);
       // ϵͳɫ
       if(hPalettehPrevPalette)
        {
         SelectPalette(hDc,hPrevPalette,FALSE);
         RealizePalette(hDc);
        }
    // ͷ豸ڴλͼ
    ReleaseDC(hWnd,hDc);
    GlobalUnlock(hImgData);
    return TRUE;
    }


{54BF6567-1007-11D1-B0AA-444553540000}


Typedef struct_GUID
{
DWORD Data1;
WORD  Data2;
WORD  Data3;
BYTE   Data48;
}GUID


extern "C" const GUID CLSID_MYSPELLCHECKER=
{0x54BF6567,0x 1007,0x 11D1
0x B0,0x AA,0x 44,0x 45,0x 53,0x54,0x00,0x00}


HRESULT CoCreateGuid(GUID pguid);


 BOOL EXPORT Initialize( );
BOOL EXPORT LoadLibrary(char);
BOOL EXPORT InsertWord(char,char );
Void  EXPORT DeleteWord(char);
BOOL EXPORT LookupWord(char,char);
BOOL EXPORT RestoreLibrary(char);
Void  EXPORT FreeLibrary( );


struct IDictionaryVtbl
struct IDictionary
  {
  IDictionaryVtbl  pvtbl;
  }
struct IDictionaryVtbl
  {
  BOOL( Initialize)(IDictionary this);
  BOOL(LoadLibrary)(IDictionary this,string);
  BOOL(InsertWord)(IDictionary this,string,string );
  Void  (DeleteWord)(IDictionary this,string);
  BOOL(LookupWord)(IDictionary this,string,string );
  BOOL(RestoreLibrary)(IDictionary this,string);
  Void (FreeLibrary)(IDictionary this);
   }


class IDictionary
  {
  virtual BOOL  Initialize( )=0;
  virtual BOOL  LoadLibrary(string)=0;
  virtual BOOL  InsertWord(string,string )=0;
  virtual Void   DeleteWord(string)=0;
  virtual BOOL  LookupWord(string,string )=0;
  virtual BOOL  RestoreLibrary(string)=0;
  virtual Void   FreeLibrary()=0;};


class CDictionary:public IDictionary
  {
  public:
  CDictionary
  ~CDictionary
  public:
  virtual BOOL  Initialize( );
  virtual BOOL  LoadLibrary(string);
  virtual BOOL  InsertWord(string,string );
  virtual void    DeleteWord(string);
  virtual BOOL  LookupWord(string,string );
  virtual BOOL  RestoreLibrary(string);
  virtual Void   FreeLibrary();
  private:
  struct DictWord m_pData;
  char m_DictFilename128;
  private:
  // other private helper function
  
  };


interface IUnknown
{
HRESULT  QueryInterface(inREFIID iid,out void  ppv)
ULONG    AddRef(void);
ULONG    Release(void);
}


class IUnknown
{
public: 
virtual HRESULT_stdcall QueryInterface(const IID& iidvoid  ppv)=0;
virtual ULONG_stdcall AddRef()=0;
virtual ULONG_stdcall Release()=0;
};


class IDictionary:public IUnknown
{
  public:
  virtual BOOL  Initialize( )=0;
  virtual BOOL  LoadLibrary(String)=0;
  virtual BOOL  InsertWord(String,String)=0;
  virtual void   DeleteWord(String)=0;
  virtual BOOL  LookupWord(String,String)=0;
  virtual BOOL  RestoreLibrary(String)=0;
  virtual void   FreeLibrary( )=0;
};
class CDictionary:public IDictionary
{
  public:
  CDictionary( );
  ~CDictionary( );
  public:
  virtual HRESULT QueryInterface(const IID&iid,void ppv);   
  virtual ULONG AddRef( );
  virtual ULONG Release( );    
  virtual BOOL Initialize( );
  virtual BOOL LoadLibrary (String);
  virtual BOOL Insertword(String,String);
  virtual void DeleteWord(String);
  virtual BOOL LookupWord(String,String );
  virtual BOOL RestoreLibrary(String);
  virtual void FreeLibrary( );
  private:
  struct DictWord   m_pData;
  char   m_DictFilename128;
  int m_Ref;
};


CDictionary::CDictionary( )
{
  m_Ref=0
  //ʼ
}
ULONG CDictionary::AddRef( )
{
  m_Ref++;
  return(ULONG) m_Ref;
}
ULONG CDictionary::Release( )
{
  m_Ref --;
  if(m_Ref==0)
  {
  delete this;
  return0;
  }
  return(ULONG) m_Ref;
}


// create a new dictionary object
IDictionarypIDictionary=CreateObject(CLSID_Dictionary,IID_Dictionary);
if(pIDictionary==NULL) return;
// after creation successfully,the reference count is 1
// load the dictiOnaly
BOOL retValue=pIDictionary >LoadLibrary("eng_ch.dict");
if(retValue==FALSE)
{
  PIDictionary >Release( );
  return;
}

IDictionary  pIDictionaryForWord=pIDictionary;
pIDictionaryForWord>AddRef( );
// Insert or delete some word
pIDictionaryForWord>InsertWord("...","...");
pIDictionaryForWord>DeleteWord("...");
pIDictionaryForWord>Release( );

// finally,release dictionary object
pIDictionary >Release( );


HRESULT  QueryInterface(inREFIID iid,outvoid   ppv);


// create a new dictionary object
IDictionary  pIDictionary=CreateObject(CLSID_Dictionary,IID_Dictionary);
ifpIDictionary==NULL return;
// after creation successfully,the reference count is 1
// load the dictionary
BOOL retValue=pIDictionary>LoadLibrary("eng_ch.dict");
if(retValue==FALSE)
{
  pIDictionary>Release( );
  return;
}

ISpellCheck   pISpellCheck;
HRESULT result =pIDictionary>QueryInterface(IID_SpellCheck,(void  ) 
&pISpellCheck;
if(result !=S_OK)
{   
  pIDictionary>Release( );
  return;
}
//...use interface pISpellCheck
// finally,release dictionary object
pIDictionary>Release( );
pISpellCheck>Release( );



pDictionary>QueryInterface(IID_Dictionary,)


pIDictionary>QueryInterface(IID_SpellCheck,(void  )&pISpellCheck);


class CDictionary:public IDictionary,public ISpellCheck
{
public:
CDictionary();
~CDictionary();
public:
// IUnknownmember function
virtual HRESULT QueryInterface(const IID& iidvoid   ppv);
virtual ULONG    AddRef();
virtual ULONG    Release();
// IDictionary member function
virtual BOOL Initialize();
// ISpellCheck member function
virtual BOOL CheckWord(Stringword);

private:
struct DictWord m_pData;
char   m_DictFilenameCl28;
int m_Ref;

};


HRESulT   CDictionary::QueryInterface(const IID& iid,void   ppv)
{
  if(iid==IID _IUnknown)
  {
  ppv=(IDictionary )this;
  ((IDictionary )(ppv))>AddRef();
  }  
  elseif(iid==IID_Dictionary)
  {
   ppv=(IDictionary  )this;
  ((IDictionary )( ppv))>AddRef();
  }
  elseif(iid==IID_SpellCheck)
  {
   ppv=(ISpellCheck  )this;
  ((ISpelICheck )(ppv))>ActdRef();
  }
  else
  {
  ppv=NULL;
  return E_NOINTEM'ACE;
  }
  return S_OK;
}


6
DATA      SEGMENT
MESS1    DB  "BUFFER OVERFLOW""$"
BUFF    DB  60  DUP(?)
DATA    ENDS
CODE    SEGMENT
ASSUME  CS:  CODEDS:  DATA
START:    MOV  AXDATA                
  MOV  DS,AX
         MOV      BX,OFFSET  BUFF      ;ͻָ
         MOV        CX,60                ;ͼֵ
         OUT        0FCH,AL              ;豸
 WAIT:    IN           AL,OFAH              ;ѯ״̬,Ϊ0,ȴ
       TEST       AL,01H
       JZ            WAIT
       IN           AL,0F8H              ;
       MOV       BX,AL
       INC           BX
       LOOP     WAIT                    ;⻺Ƿ,
       MOV       DX,OFFSET MESS1          ;,־ַ
       MOV       AH,09H
       INT             21H
       MOV       AH,4CH
       INT            21H
 CODE    ENDS
  END STAR


    MOV    AL,    68H        ;OCW3Ϊ01101000,ESMM=SMM=1
    OUT      80H,    AL


    MOV    AL,    48H
    OUT      80H,    AL        ;OCW3Ϊ01001000,ESMM=1SMM=0


MOV    AL,    0CH        
    OUT      80H,    AL          ;OCW3Ϊ00001100,P=1òѯʽ
    IN          Al,    82H          ;ѯ


   MOV    AL,    0BH        
    OUT      82H,    AL          ;OCW3Ϊ00001011,RR=1RIS=1,жϷĴISR
    IN          Al,    80H          ;ISRݵAL


MOV    AL,    0AH        
    OUT      80H,    AL      ;OCW3Ϊ00001010,RR=1RIS=0,жĴIRR
    IN          Al,    82H          ;IRRݵAL


  MOV    AL,    20H                ;ͨEOI
        OUT      20H,      AL          ;20HΪƬַ


        MOV    AL,    20H                ;ͨEOI
        OUT      0A0H,      AL          ;0A0HΪƬƬַ
        OUT      20H,      AL          ;20HΪƬַ


        PUSH    AX    
        MOV      AL,      20H    
        OUT      20H,      AL
        POP          AX
        INT          0AH


    MOV    AL,0
    OUT      0EH,AL


OUT    0DH,AL                ;DMAC
MOV      AL,0          ;DMAC,̶Ȩ, DREQЧ, DACKЧ
OUT      08H,AL
MOV      AL,0
OUT      00H,AL          ;дͨ0ĵַĴֽ
OUT      00H,AL          ;дͨ0ĵַĴֽ
MOV      AL,0FFH    
OUT      01H,AL          ;дͨ0ֽڼĴֽ
OUT      01H,AL          ;дͨ0ֽڼĴֽ
MOV      AL,58H      ;ͨ0ģʽ,ֽڴ,DMA,ַ,Զʼ
OUT      0BH,AL
MOV      AL,0H          ;ͨ0:  DREQ0
OUT      0AH,AL


START:  OUT    7DH,AL                ;λ/󴥷Ϊ0
  MOV      AL,00H
  OUT      72H,AL          ;2000Hд͵ǰַĴ
  MOV      AL, 20H
  OUT      72H ,AL
  MOV      AX ,1000          ;ֽ1000
  DEC      AX                   ;ֵΪ1000-1
  OUT      73H,AL          ;ֵд(ǰ)ֽڼ
  MOV      AL,AH
  OUT      73H,AL
  MOV      AL,85H          ;鴫,ַ1,д
  OUT      7BH, AL          ;дʽ
  MOV      AL,01H 
  OUT      7AH,AL          ;д,ͨ1 
  MOV      AL ,00H          ;DACK1 = 0 , DREQl = 1,8237A 
  OUT      78H ,AL           ;д


START:  OUT    7DH, AL        ;λ,/󴥷Ϊ0
              MOV       AL , 00H          ;Դַдͨ0 ַĴ
              OUT      70H,AL      ;дλַ
              MOV      AL , 20H
              OUT      70H, AL           ;дλַ
              MOV      AX , 1000H      ;ֽ1000H дͨ0ֽڼ
              DEC      AX              ;ֵ
              OUT      71H,AL          ;дλֵ
              MOV      AL, AH
              OUT      71H , AL          ;дλֵ
              MOV      AL , 00H          ;Ŀĵַдͨ1 ַĴ
              OUT      72H , AL
              MOV      AL , 40H 
              OUT      72H,    AL 
              MOV      AX , 1000H      ;ֽl000H дͨ1ֽڼ
              DEC      AX              ;ֵ
              OUT      73H , AL 
              MOV      AL, AH
              OUT      73H , AL
              MOV      AL , 88H          ;鴫,ַ1 ,
              OUT      7BH, AL           ;дͨ0ʽ
              MOV      AL,85H          ;鴫,ַ1 ,д
              OUT      7BH,AL           ;дͨ1 ʽ
              MOV      AL,    81H
              OUT      78H,AL          ;дĴ,洢֮䴫
              MOV      AL,    04H        
              OUT      79H,    AL          ;дĴ,DMAͨ0
              MOV      AL,    00H
              OUT      0FH,AL          ;дμĴ,ȫDMA


    MOV    AL,    13H    
OUT      20H,          AL
    MOV      AL,          08H   
 OUT      21H,        AL 
   MOV      AL,         09H    
OUT      21H,          AL


  MOV    AL,    0BH  
  OUT      20H,          AL
  NOP 
  IN          AL,          20H


    MOV    AL,    0BCH 
   OUT      21H,          AL


7
MOV    DX,    38BH    ;ƶ˿ڵַ͵DX
MOV  AL,33H  ;: 
OUT  DX,AL  ;д뷽ʽƶ˿
MOV  AL,40H   
MOV  DX,388H   
OUT  DX,AL  ;8λд0Ķ˿ڵַ
MOV  AL,30H
OUT  DX,AL  ;8λд0Ķ˿ڵַ


MOV    DX,    38BH    
MOV  AL,    40H  ;01000000
OUT  DX,    AL  ;д뷽ʽƶ˿
MOV  DX,    389H
IN  AL,    DX  ;Ӽ1ĵַ8λ
MOV  CL,    AL
IN  AL,    DX  ;Ӽ1ĵַ8λ
MOV  CH,    AL


MOV    DX,    38BH    
MOV  AL,    0C4H  ;11000100,أ
OUT  DX,    AL  ;д뷽ʽƶ˿
MOV  DX,    389H
IN  AL,    DX  ;Ӽ1ĵַ״̬
MOV  BL,    AL
IN  AL,    DX  ;Ӽ1ĵַ8λ
MOV  CL,    AL
IN  AL,    DX  ;Ӽ1ĵַ8λ
MOV  CH,    AL


MOV    AL,    36H    ;0ĿΪ00110110
OUT  43H,    AL
MOV  AL,    0
OUT  40H, AL  ;0ĳֵΪ0000
OUT  40H, AL


MOV    AL,54H    ;1ĿΪ01010100
OUT  43H,AL
MOV  AL,18  ;1ĳֵΪ18
OUT  41H,AL


 BEEP    PROC  FAR
     MOV     AL,0B6H    ;210110110,ʽ3,16λ,
  OUT  43H,AL
  MOV  AX,1190  ;ֵΪ1190,Ƶ=1.193/1190=1kHz
  OUT  42H,AL
  MOV  AL,AH
  OUT  42H,AL  ;ȵͺ,ֵ
  IN  AL,61H
  MOV  AH,AL
  OR  AL,03H
  OUT  61H,AL  ;ϳ8255APB1PB0޸Ϊ1,
      ;ԭֵAH,Աָ
  MOV  CX,0
  L0:   LOOP      L0
  DEC  BL
   JNZ  L0  ;˶ѭΪʱ,BLΪBEEPӳ
      ;,BL=6ʾ;=1ʾ
  MOV  AL,AH
  OUT  61H,AL  ;ָ8255AB˿ԭֵ
  RET
BEEP    ENDP


MOV    AL,0FAH
OUT  52H,AL
MOV  AL,37H
OUT  52H,AL


MOV    AL,18H
OUT  52H,AL
MOV  AL,16H
OUT   52H,AL
OUT  52H,AL
MOV  AL,97H
OUT  52H,AL


        MOV    AL, 0FAH        
      OUT  52H, AL  ;Ҫģʽ
      MOV  AL, 35H
      OUT  52H, AL  ;ÿ,,ʶ
      MOV  DI, 0  ;ַĴʼ
      MOV  CX, 80  ;ȡ80ַ
BEGIN:   IN   AL, 52H  ;ȡ״̬,RxRDY λǷΪ1
      TEST  AL, 02H
      JZ  BEGIN  ;Ϊ0ʾδյַ,ʼȡ״ֲ̬
      IN  AL, 50H  ;ȡַ
      MOV  BX, OFFSET BUFFER
      MOV  BX + DI,AL  ;ַ뻺
      INC  DI  ;޸Ļָ
      lN  AL, 52H  ;ȡ״̬
      TEST  AL, 38H  ;֡ʽ,/żУ͸Ǵ,
      JNZ  ERROR  ;,ת
      LOOP  BEGIN  ;ûд,ٽһַ
      JMP  EXIT  ;80 ַ,
ERROR:      
      CALL  ERR _ OUT  ;ó
    EXIT:   


INIT:                           
    XOR  AX, AX  ;AX 
    MOV  CX,     0003
    MOV  DX, 00DAH    ;DXĴΪƶ˿ڵַ
OUT1: 
    CALL  KKK
LOOP  OUT1    ;8251AĿƶ˿30
MOV  AL, 40H
CALL  KKK    ;8251AĿƶ˿140Hʹλ
MOV  AL, 4EH    ;ģʽ֣첽ģʽ;Ϊ16 
      ;8 λݣ1λֹͣλ
CALL  KKK
MOV  AL, 27H    ;֣ʹͽ
CALL  KKK

KKK:       ;ӳ򣬽ALеDXָ˿
    OUT  DX,    AL
PUSH  CX
MOV  CX0002
ABC:  
    LOOP  ABC    ;ȴ
POP  CX    ;ָCX ݣ
RET


CHAROUT:                      
    MOV  DX , 0DAH  ;״̬˿DAH״̬
STATE: 
    IN  AL, DX
TEST  AL , 01  ;״̬λTxRDY ǷΪ1粻ǣٲ
JZ  STATE
MOV  DX ,0D8H  ;DXĴΪݶ˿ں
POP  AX  ;AXΪҪַ
OUT  DX , AL  ;˿һַ


MOV    DX,0FF83H    
MOV  AL,86H  ;ûõļλд0
OUT  DX,AL


MOV    DX,0FF83H    
MOV  AL,05H  ;ûõļλд0
OUT  DX,AL


MOV    AL,99H    ;AڡCΪʽ0룬 BΪʽ0
OUT  63H,AL


MOV    AL,80H    ;ʹPB71
OUT  61H,AL
IN  AL,60H  ;A˿Ϣ,ΪDIP SW1״̬


DATA    SEGMENT    
  LIST  DB  3FH,06H,5BH,4FH,66H,6DH,7DH,
  07H,7FH,6FH,77H,7CH,39H,5EH,79H,71H
DATA  ENDS
CODE  SEGMENT
ASSUME    CS:     CODE,  DS:  DATA
    START:    MOV  AX,     DATA            
  MOV  DS,AX
  MOV  AL,90H;A˿ڷʽ0
;B˿ڷʽ0
  MOV  DX,  0FFE3H
  OUT  DX,  AL
  L0:  MOV  DX,0FFE0H
  IN  AL,  DX;ȡA˿״̬
  AND  AL,  0FH;A˿ڸ4λ
  MOV  BX,    OFFSET LIST
AND  AX,  00FFH
ADD  BX,  AX
MOV  AL,  BX
  

  ;õӦĹ
  ;LED
  MOV  DX,  0FFE1H;B˿
  OUT  DX,  AL
  CALL  DALLY
  JMP  L0
  DALLY:   ;ʱӳ
  
  CODE  ENDS
  END  START


      
      MOV    AL,0A8H          ;Aڷʽ1PC4 PC5ʽ0
  OUT  43H,AL
  MOV  CX,100  ;ֽ
  MOV  SI,OFFSET    BUFFER  ;SIΪ׵ַ  
L1:      IN  AL,    42H  ;ȡC˿״̬
  AND  AL,    10H
  JNZ  L1  ;BUSY=1ǣѯ
  MOV  AL,    SI
  OUT  40H,        AL  ;ͨA
  INC  SI
  LOOP  L1  ;δꣿ
  


8
MOV  DX,  280H    ;DAC0832ĵַΪ280H
OUT  DX,  AL  ;ALDACת


MOV  DX,  200H    ;DAC0832 ĵַΪ200H
OUT  DX,  AL  ;AL DATAĴ
MOV  DX,  201H  ;DAC0832 DACĵַΪ201H
OUT  DX,  AL  ;DATAдDACת


MOV  DX,  PA8255    ;8255AڵַΪPA8255
  OUT  DX,  AL  ;AL A 沢ת


      MOV    DX,PORTAD      ;DAC˿ڵַΪPORTD
          MOV      AL,  0              ;ֵ
P1:          OUT      DX,  AL
          INC          AL
          JMP          P1


MOV    DX,280H  ;򿪵һ4λ4λ
OUT      DX,  AL              ;8λ
INC          DX
MOV      AL,  AH
OUT      DX,  AL              ;4λ,ͬʱ򿪵һ
  ;4λ,4λ4λдڶ
  ;


      MOV    BX,  OFFSET BUF
      MOV    CX,  8          ;CXͨ
                  MOV      DX,  220H
    P1:              OUT      DX,  AL                  ;A/Dת,AL޹
                  PUSH      DX
                  MOV      DX,  238H
    P2:              IN          AL,  DX                  ;EOC״̬
                  TEST      AL,  80H
                  JZ          P2                    ;תûн,ѯ
                  POP          DX
                  IN          AL,  DX                  ;A/Dת
                  MOV      BX,  AL
                  INC          BX
                  INC          DX
                  LOOP      P1


MOV    DX,PORT0        ;8λݵַ,ɼ8λ
IN          AL,  DX 
MOV      AH,  AL 
MOV      DX,  PORT1           ;4λݵַ,λ40
IN          AL,  DX               ;γ12 λ


        MOV  DX,PORT0      ; PORT0Ϊɼ8λݿڵַ(A0=0)
  OUT       DX,  AL              ;A / D ת
  MOV       DX,  STSADD          ;STSADDΪ̬ŵַ
LOOP :      IN           AL,  DX               ;STS״̬
  TEST      AL,  01H 
  JNZ       LOOP             ;STS=1ȴ
  MOV      DX,  PORT0          ;STS=0,8λ
  IN           AL,  DX
  MOV      AH,  AL
  MOV      DX,  PORT1          ;PORT1Ϊ4λݿڵַ(A0=1),4λ
  IN          AL,   DX
