комментарии к программам

number_of_lines = 5
line_length = 5
 
.model tiny
code    segment para public 'code'
.386                ;for SHL command
 
org 100h
 
start:  
    mov ax,03h      ;set text regime N3 (80x25)
    int 10h
    
    mov dx,0b800h   ;video memory address in ES register
    mov es,dx
    
    mov bx,73afh    
    mov cx,38a0h
    mov ax,6493h
    mov dx,8375h
    
    add cx,dx       ;addition of junior parts
    adc bx,ax       ;addition with shift
    
    push    bx
    and bx,0f000h
    shr bh,4
    mov al,bh
    call    alg_das
    pop bx
    
    push    bx
    and bx,0f00h
    mov al,bh
    call    alg_das
    pop bx
    
    push    bx
    and bx,00f0h
    shr bl,4
    mov al,bl
    call    alg_das
    pop bx
    
    push    bx
    and bx,000fh
    mov al,bl
    call    alg_das
    pop bx
    
    push    cx
    and cx,0f000h
    shr ch,4
    mov al,ch
    call    alg_das
    pop cx
    
    push    cx
    and cx,0f00h
    mov al,ch
    call    alg_das
    pop cx
    
    push    cx
    and cx,00f0h
    shr cl,4
    mov al,cl
    call    alg_das
    pop cx
    
    push    cx
    and cx,000fh
    mov al,cl
    call    alg_das
    pop cx
    
        mov     dx,offset new_line  ;copy new line offset to video memory                    
        mov     ah,9                                             
        int     21h 
      
    mov ax,0008h        ;negative number output
    mov bx,0009h
    cmp ax,bx
    jb  m2
    jae m3
m1:
    mov     dx,offset new_line  ;copy new line offset to video memory                       
        mov     ah,9                                             
        int     21h
        
    mov cx,number_of_lines  ;matrix output
    mov si,0
copy_lines:
    mov dx,screens[si]
    mov ah,09h
    int 21h
    inc si
    inc     si
    loop    copy_lines
    
    xor ax,ax
    int     16h
m2:
    sub ax,bx
    neg ax
    push    ax
    mov dl,2dh      ;negation sign output 
    mov ah,02h
    int 21h
    pop ax
    cmp al,10
    sbb al,69h
    das         ;put symbol`s ASCII-cod into al
    mov dl,al
    mov ah,02h
    int 21h
    jmp m1
m3:
    sub ax,bx
    call    alg_das
    jmp m1
    
alg_das:    
    cmp al,10
    sbb al,69h
    das         ;put symbol`s ASCII-cod into al
    mov dl,al
    mov ah,02h
    int 21h     ;print AL`s content 
    
    ret
    
screen1 db  "  **    ",0dh,0ah,'$'
screen2 db  "   **   ",0dh,0ah,'$'
screen3 db  "    **  ",0dh,0ah,'$'
screen4 db  "     ** ",0dh,0ah,'$'
screen5 db  "      **",0dh,0ah,'$'
 
screens dw  screen1,screen2,screen3,screen4,screen5
 
new_line db     13,10,"$"
 
rowlen  db  80
 
code ends   
end start

;  A 16-bit DOS HelloWorld program originally by RedOx.  Produces a small model .EXE executable.
 
; To assemble and link from within WinAsm Studio, you must have a special 16-bit linker, 
; such as the one in the archive at this URL- [url]http://win32assembly.online.fr/files/Lnk563.exe[/url]
; Run the archive to unpack Link.exe, rename the Link.exe file to Link16.exe and copy it
; into the \masm32\bin folder.
 
.MODEL  small
.386
 
stk segment para stack 'stack'
    db  100h dup(?)
stk ends
 
data    segment para public 'data'
    msg         db "Lab 2 var 4.", 0Dh, 0Ah, "Input text:", 0Dh, 0Ah, "$"   ; The string must end with a $
    msg_min     db "Min length word: $"
    msg_max     db "Max length word: $"
    next_line   db 0Dh, 0Ah, "$"
    
    buffer      db 255
    blength     db ? 
    bcontents   db 255 dup(?)
    
    outbuffer   db 258 dup(?)
    
    minwordpos  dw ?
    minwordlen  db 255
    maxwordpos  dw ?
    maxwordlen  db 0
    
data    ends
 
code    segment para public 'code'
    assume  cs:code, ds:data, ss:stk
start:
    mov     ax, data        ; Get the address of the data segment
    mov     ds, ax          ; Set the DS segment
     
    mov     dx, offset msg  ; Get the address of our message in the DX
    mov     ah, 9           ; Function 09h in AH means "WRITE STRING TO STANDARD OUTPUT"
    int     21h             ; Call the DOS interrupt (DOS function call)
    
    mov     dx, offset buffer
    mov     ah, 0Ah
    int     21h
    
    mov     dx, offset next_line
    mov     ah, 9
    int     21h
    
    xor     di, di          ; di - current char index
    xor     si, si          ; si - word start index
    xor     cx, cx          ; cx - current word length
    
space_char_loop:
    ; bl - current character from input string
    mov     bl, byte ptr bcontents[di]
    cmp     bl, 20h
    je      word_end
 
    cmp     bl, 0Dh
    je      string_end
 
    inc     di
    inc     cx
    jmp     space_char_loop
    
word_end:
    call    CheckLen
    inc     di
    mov     si, di
    xor     cx, cx
    jmp     space_char_loop
 
string_end: 
    call    CheckLen
    
    ; output "min word" message
    mov     dx, offset msg_min
    mov     ah, 9
    int     21h
    
    ; output min length word
    mov     si, minwordpos
    mov     cl, minwordlen
    call    OutputWord
    
    ; output "max word" message
    mov     dx, offset msg_max
    mov     ah, 9
    int     21h
 
    ; output max length word
    mov     si, maxwordpos
    mov     cl, maxwordlen
    call    OutputWord
 
    mov     ax, 0C07h       ; Function 0Ch = "FLUSH BUFFER AND READ STANDARD INPUT"
    int     21h             ; Waits for a key to be pressed.
    
    mov     ax, 4C00h       ; the exit fuction [4C+no error (00)]
    int     21h             ; call DOS interrupt 21h
 
; checks if current word length updates min/max records (cl - current length, si - word start index)
CheckLen proc
    test    cl, cl
    jz      CLproc_exit
    
    cmp     cl, maxwordlen
    jbe     CLproc_check_less
    
    mov     maxwordpos, si
    mov     maxwordlen, cl
    
CLproc_check_less:
    cmp     cl, minwordlen
    jae     CLproc_exit
    
    mov     minwordpos, si
    mov     minwordlen, cl
 
CLproc_exit:
    Ret
CheckLen endp
    
; outputs word (si - word start index, cx - word length)
OutputWord proc
    xor     di, di
    
OWproc_copy_char:
    ; si - current index in input string
    ; di - current index in output string
    ; bl - current character from input string
    mov     bl, bcontents[si]
    mov     outbuffer[di], bl
    inc     si
    inc     di
    loop    OWproc_copy_char
    
    mov     outbuffer[di], 0Dh
    mov     outbuffer[di+1], 0Ah
    mov     outbuffer[di+2], '$'
    
    mov     dx, offset outbuffer
    mov     ah, 9
    int     21h
    
    Ret
OutputWord endp
 
code ends
 
end start