pm1.asm

cxzv dvsdsd sd fsdf sdf sd f

.386P              
descr struc              
 limit  dw 0     
 base_l dw 0      
 base_m db 0     
 attr_l db 0                               
 attr_2 db 0      
 base_h db 0     
descr ends       
                 
data segment           
 gdt_null descr <0,0,0,0,0,0>  
 gdt_data descr <data_size-1,0,0,92h>
 gdt_code descr <code_size-1,,,98h>
 gdt_stack descr <255,0,0,92h>       
 gdt_screen descr <4095,8000h,0Bh,92h,0,0> 
 gdt_size=$-gdt_null        
                                   
 pdescr  dq 0               
 sym     db 1               
 attr    db 1Eh                                         
 mes     db 27,'[31;42m Back To Real Mode!  ',27,'[0m$'
 data_size=$-gdt_null                                  
data ends                   
                            
text segment 'code' use16                  
 assume cs:text,ds:data     
 main proc                  
      xor eax,eax           
      mov ax,data           
      mov ds,ax             
                            
      shl eax,4             
      mov ebp,eax           
      lea bx,gdt_data; mov bx,offset gdt_data
      mov [bx].base_l,ax    
      rol eax,16             
      mov [bx].base_m,al     
                             
      xor eax,eax            
      mov ax,cs              
      shl eax,4              
      lea bx,gdt_code ;mov bx,offset gdt_code
      mov [bx].base_l,ax     
      rol eax,16             
      mov [bx].base_m,al                   
                             
      xor eax,eax            
      mov ax,ss              
      shl eax,4              
      lea bx,gdt_stack ;mov bx,offset gdt_stack
      mov [bx].base_l,ax     
      rol eax,16             
      mov [bx].base_m,al     
                             
      mov dword ptr pdescr+2,ebp
      mov word ptr pdescr,gdt_size-1
      lgdt pdescr            
                             
      cli                    
      mov al,80h             
      out 70h,al             
                             
      mov eax,cr0            
      or eax,1               
      mov cr0,eax                          
                             
      db 0EAh                
      dw offset continue     
      dw 16                  
                             
      continue: mov ax,8     
                mov ds,ax    
                             
                mov ax,24    
                mov ss,ax    
                             
                mov ax,32    
                mov es,ax    
                mov bx,800   
                mov cx,640   
                mov ax,word ptr sym
        screen: mov es:[bx],ax
                add bx,2     
                inc ax       
                loop screen                
                             
                mov gdt_data.limit,0FFFFh      
                mov gdt_code.limit,0FFFFh
                mov gdt_stack.limit,0FFFFh
                mov gdt_screen.limit,0FFFFh
                             
                mov ax,8     
                mov ds,ax    
                mov ax,24    
                mov ss,ax    
                mov ax,32    
                mov es,ax    
                             
                db 0EAh      
                dw offset go 
                dw 16        
                             
            go: mov eax,cr0                
                and eax,0FFFFFFFEh
                mov cr0,eax                
                                           
                db 0EAh                    
                dw offset return           
                dw text                    
                                           
                                           
        return: mov ax,data                
                mov ds,ax                  
                mov ax,stk                 
                mov ss,ax                  
                                           
                sti                        
                mov al,0                   
                out 70h,al                 
                                           
                mov ah,09h                 
                lea dx,mes                 
                int 21h                    
                                           
                mov ax,4c00h               
                int 21h                    
 main endp                                 
 code_size=$-main                          
 text ends                                 
 stk segment stack 'stack'                 
     db 256 dup ('^')                      
 stk ends                                  
                                           
 end main