汇编语言——更灵活的定位内存地址的方法

and和or指令

1、and指令

将2进制中的1当做真，2进制中的0当做假

则：只有2个事件都为真的时候才为真，即1&&1==>1，1&&0==>0，0&&0==>0；

用处：假如想把一个数的第7位变成0，让它和01111111B执行与操作就好了

mov al,10001101B    ; 8位数据

add al,01111111B

>> (al)=00001101B

2、or指令

只要2个事件中有1个是真即为真，即1||1==>1，1||0==>1，0||0==>0；

用处：假如想把一个数的第7位变成1，让它和10000000B执行或操作就好了

mov al,01101101B    ; 8位数据

or al,10000000B

>> (al)=11101101B

ASCII码

大小写转换

由上图可以得知大写字母的ASCII码比小写字母的ASCII码小32（20H），也就是说大写字母和小写只有第5位不同（大写：0，小写：1）

大写     二进制             小写       二进制
 A         01000001          a         01100001
 B         01000010          b         01100010
 C         01000011          c         01100011
 D         01000100          d        01100100

示例：将BaSiC全部变成大写，将iNfOrMaTiOn全部变成小写。

assume cs:codesg,ds:datasg
datasg segment
    db 'BaSiC'            ; 0~4内存单元
    db 'iNfOrMaTiOn'    ; 5~15内存单元
datasg ends

codesg segment
 start: mov ax,datasg
        mov ds,ax
        mov bx,0
        mov cx,5        ; 循环5次
        
        ; 将BaSiC全部变成大写
      s:mov al,[bx]          ; 获取相应内存单元的值，赋给al低位寄存器
        add al,11011111B; 将第5位变成0
        mov [bx],al        ; 将修改后的放回之前的内存单元
        inc bx            ; bx自增1
        loop s
        
        mov bx,5
        mov cx,11
        ; 将iNfOrMaTiOn全部变成小写
     s0:mov al,[bx]
        or al,00100000B ; 将第5位变成0
        mov [bx],al
        inc bx
        loop s0
  
codesg ends
end start

[bx+idata]

我们可以用[bx]的方式来指明一个内存单元， 我们还可以用一种更为灵活的方式来指明内存单元：
[bx+idata]表示一个内存单元，它的偏移地址为(bx)+idata（bx中的数值加上idata）。

示例：使用[bx+idata]，将BaSiC全变小写，将MinIX全变大写

assume cs:codesg,ds:datasg
datasg segment
    db 'BaSiC'        ; 内存单元0-4
    db 'MinIX'        ; 内存单元5-9
datasg ends

codesg segment
 start: mov ax,datasg
        mov ds,ax
        
        mov bx,0
        mov cx,5
        
      s:mov al,[bx]
        or al,00100000B        ; 或操作，全变成小写
        mov [bx],al
        
        mov bl,[bx+5]
        and al,11011111B    ; 与操作，全变成大写
        mov [bx+5],al
        inc bx
        loop s
        
        mov ax,4c00H
        int 21H
 
codesg ends
end start

SI和DI寄存器

si和di寄存器和ds寄存器的作用一样，都是用来表示内存的偏移地址的。只是SI和DI不能够分成两个8 位寄存器来使用。

我们还可以这样使用它们：[bx+si]，[bx+di]和[bx+si+idata]，[bx+di+idata]，其实和[dx+idata]一样

示例：*****

将datasg段中每个单词改为大写字母

我们很容易就会想到以下代码，因为在第2层循环中修改了cx。等它们跳出第二层循环时cx=0，第一层循环会执行cx=cx-1 ==>-1(FFFF)，从而进入死循环

assume cs:codesg,ds:datasg
datasg segment
   db 'ibm            '        ; 16个字节 0-15
   db 'dec            '        ; 16-31
   db 'dos            '        ; 32-47
   db 'vax            '        ; 48-63
datasg ends

codesg segment
 start: ; 因为要将每行的每个单词改为大写，所以我们需要写两层循环
        mov ax,datasg
        mov ds,ax
        mov bx
        mov cx,4
      s:mov cx,3
        mov so,0    ; 这个要写在外面
     s0:   
        mov al,[bx+si]  
        add al,11011111B
        mov [bx+si],al
        inc si        ; 如果是将bx+1的话，就会1,2,3,13,14,15,...这样，所以我们要用si/di寄存器
        loop s0
        
        add bx,16
        loop s
        
        mov ax,4c00H
        int 21H
        
codesg ends
end start

我们可以采用把cx的值放进其他寄存器中，但寄存器是有限的，当程序过大就不够用了

assume cs:codesg,ds:datasg
datasg segment
   db 'ibm            '        ; 16个字节 0-15
   db 'dec            '        ; 16-31
   db 'dos            '        ; 32-47
   db 'vax            '        ; 48-63
datasg ends

codesg segment
 start: 
        mov ax,datasg
        mov ds,ax
        mov bx
        mov cx,4
      s:mov cx,3
        mov dx,cx    ;;;;;; 用其他寄存器保存一下
      
     s0:mov si,0    
        mov al,[bx+si]  
        add al,11011111B
        mov [bx+si],al
        inc si        
        loop s0
        
        add bx,16
        mov cx,dx    ;;;;; 将cx取出
        loop s
        
        mov ax,4c00H
        int 21H
        
codesg ends
end start

然后我们可以把他放进内存中，内存是可以随便用的啊，但当循环多的时候，你需要把所以内存位置都记住。这很不方便

assume cs:codesg,ds:datasg
datasg segment
   db 'ibm            '        ; 16个字节 0-15
   db 'dec            '        ; 16-31
   db 'dos            '        ; 32-47
   db 'vax            '        ; 48-63
   dw  0        ;;;;; 定义一个字来保存cx的值（64）
datasg ends

codesg segment
 start: 
        mov ax,datasg
        mov ds,ax
        mov bx,0
        mov cx,4
      s:mov cx,3
        mov [64],cx    ;;;;;; 放进字单元中保存一下
        mov si,0    
     s0:    
        mov al,[bx+si]  
        add al,11011111B
        mov [bx+si],al
        inc si        
        loop s0
        
        add bx,16
        mov cx,[64]    ;;;;; 将cx取出
        loop s
        
        mov ax,4c00H
        int 21H
        
codesg ends
end start

所以我们要使用栈的方式来进行两层循环的嵌套

这样做的好处是：多层循环嵌套的话，每一层往里面push一个值，等它出来的时候pop的值就是那个，我们只需要管理一个栈就好了，不用管其他的。

assume cs:codesg,ds:datasg,ss:stacksg
datasg segment
   db 'ibm            '        ; 16个字节 0-15
   db 'dec            '        ; 16-31
   db 'dos            '        ; 32-47
   db 'vax            '        ; 48-63
datasg ends

stacksg segment
    dw 0,0,0,0,0,0,0,0        ;;;;; 定义一个栈段

codesg segment
 start: 
        mov ax,datasg
        mov ds,ax
        mov ax,stacksg        ;;;;; 保存栈段的位置
        mov ss,ax            ;;;;; 赋值给ss
        mov sp,16            ;;;;; 指向栈顶
        mov bx,0
        mov cx,4
      s:mov cx,3
        push cx    ;;;;;; 入栈
        mov si,0    
     s0:    
        mov al,[bx+si]  
        add al,11011111B
        mov [bx+si],al
        inc si        
        loop s0
        
        add bx,16
        pop cx     ;;;;; 出栈
        loop s
        
        mov ax,4c00H
        int 21H
        
codesg ends
end start