Постановка ограничений для вводимого по символу числа относительн его типа(db,dw)

[macomics]

_break:
        cmp [shet],7
        jz proverka_d
        rcl [shet], 1
        jmp proverka_drygix

Вот так попробуйте. Тогда первые 3 операции будут идти по метке proverka_drygix, а третий проход пойдет на метку proverka_d

[alonil]

Спасибо.Уже программа работает.

[alonil]

В начале так хорошо всё выходило.А теперь даже не знаю...Ура!!Получилось,думал я.Ограничения ,то она стала учитывать.А вот считать правильно перестала выражение.Я так расстроился.Делал делал.И тут бац тебе неправильно.Ну вот же прошлая прога работала,всмысле считала правильно,хорошо,только не учитывала ограничения.А стал переделывать ,чтоб она ограничения учитывала и всё...Можете помочь с кодом ,пожалуйста.Думал сегодня сделаю,но увы .Для меня оказалось неожиданным,что она неправильно считает.выбило меня из сил...Прошу о помощи.Копался я с ней полдня.И в итоге оказалось,что результат .....

.model small
 data segment
        msg_a db 13,10, "a = ", '$'
        msg_b db 13,10, "b = ", '$'
        msg_c db 13,10, "c = ", '$'
        msg_d db 13,10, "d = ", '$'
        msg_result db 13,10, "a*c*(a+b)-d = ", '$'
        a db ?
        b db ?
        c db ?
        d dw ?
        result dw ?
data ends
stk segment stack
    db 256 dup(?)
stk ends
code segment
    assume cs: code, ds: data, ss: stk 
 start:
        mov ax, data
        mov ds, ax
 Vvod_peremenou:
        mov ah, 09h
        lea dx, [msg_a]
        int 21h
        mov di, offset store_A
        jmp ReadInt16
store_A:
        mov [a], al
        
        mov ah, 09h
        lea dx, [msg_b]
        int 21h
        mov di, offset store_B
        jmp ReadInt16
store_B:
        mov [b], al
        
        mov ah, 09h
        lea dx, [msg_c]
        int 21h
        mov di, offset store_C
        jmp ReadInt16
store_C:
        mov [c], al
        
        mov ah, 09h
        lea dx, [msg_d]
        int 21h
        mov di, offset store_D
        jmp ReadInt16
store_D:
        mov [d], ax
 Vichislenia:       
        mov al,[a]
        imul [c]
        mov  bx, ax
        mov al,[a]
        add al,[b]
        cbw
        imul bx
        sub  ax,[d]
        mov  [result],  ax
Vivod_resultata:      
        mov     ah,     09h
        lea     dx,     [msg_result]
        int     21h
        mov     ax,     [result]

Vivod_result:        
        mov     bx,     10      
        xor     cx,     cx      
        or      ax,     ax     
        jns     _div
                neg     ax      
                push    ax      
                mov     ah,     02h
                mov     dl,     '-'
                int     21h
                pop     ax
        _div:                  
                xor     dx,     dx
                div     bx
                push    dx      
                inc     cx      
                or      ax,     ax
                jnz     _div           
        mov     ah,     02h
        store:
                pop     dx      
                add     dl,     '0'    
                int     21h     
        loop    store
ReadInt16:
        xor     bx,     bx      
        xor     cx,     cx      
        do:
                mov     ah,     00h 
                int     16h
                
                mov dl, al 
                cmp al, 0Dh 
                je  _break
                cmp al, '-'
                jne  @endif
                mov  bx, 1
                        jmp     putchar
                @endif:
                sub al, '0'
                jc do
                cmp al, 9+1
                jnc    do
                xor     ah,     ah
                shl     cx,     1      
                mov     si,     cx
                shl     cx,     1
                shl     cx,     1
                add     cx,     si
                add     cx,     ax     
        putchar:
                mov     ah,     02h
                int     21h
        jmp     do
_break:
        mov  ax, cx
        
        test bx, bx
        jz  exit
        neg  ax
exit:
        jmp di

        mov     ax,     4C00h
        int 21h
code ends
end    start

ПОЖалуйстааа

[macomics]

Первое

        mov     ax,     4C00h
        int 21h
code ends

Вы вот эти две строки зачем утащили вниз. Это вызов функции выхода в DOS. Они должный быть ...

Vivod_resultata:      
        mov     ah,     09h
        lea     dx,     [msg_result]
        int     21h
        mov     ax,     [result]
; ... здесь

Второе

stk segment stack
    db 256 dup(?)
stk ends

Вот вы задаете программе стек, но почему же не используете команду call для вызова?

Третье

        msg_a db 13,10, "a = ", '$'
        msg_b db 13,10, "b = ", '$'
        msg_c db 13,10, "c = ", '$'
        msg_d db 13,10, "d = ", '$'
        msg_result db 13,10, "a*c*(a+b)-d = ", '$'
        a db ?
        b db ?
        c db ?
        d dw ?
        result dw ?

Вот ваши переменные и данные, которые можно расположить иначе или использовать массив для создания цикла ввода без необходимости задания вот такой длинной последовательности

 Vvod_peremenou:
        mov ah, 09h
        lea dx, [msg_a]
        int 21h
        mov di, offset store_A
        jmp ReadInt16
store_A:
        mov [a], al
        
        mov ah, 09h
        lea dx, [msg_b]
        int 21h
        mov di, offset store_B
        jmp ReadInt16
store_B:
        mov [b], al
        
        mov ah, 09h
        lea dx, [msg_c]
        int 21h
        mov di, offset store_C
        jmp ReadInt16
store_C:
        mov [c], al
        
        mov ah, 09h
        lea dx, [msg_d]
        int 21h
        mov di, offset store_D
        jmp ReadInt16
store_D:
        mov [d], ax

Задайте массив с метками

        InputOrderA dw msg_a, a, test_byte
        InputOrderB dw msg_b, b, test_byte
        InputOrderC dw msg_c, c, test_byte
        InputOrderD dw msg_d, d, test_word
        msg_a db 13,10, "a = ", '$'
        msg_b db 13,10, "b = ", '$'
        msg_c db 13,10, "c = ", '$'
        msg_d db 13,10, "d = ", '$'
        msg_overflow db 13,10,"Error: Integer overflow!", '$'
        msg_result db 13,10, "a*c*(a+b)-d = ", '$'
        a db ?
        b db ?
        c db ?
        d dw ?
        result dw ?

И теперь перебирая элементы этого массива (InputOrder) можно выводить сообщения о вводе элемента, тестировать границы на byte(db) или word(dw) и сохранять в соответствующую переменную

    lea bx, InputOrderA
input_loop:
    mov dx, [bx]
    mov ah, 9
    int 33
    xor cx, cx
    xor si, si
    xor ah, ah
    int 22
    cmp al, '-'
    jnz check_digit
    inc cl

digit:
    mov ah, 0
    mov dx, si
    add si, si
    jc overflow
    add si, si
    jc overflow
    add si, dx
    jc overflow
    add si, si
    jc overflow
    add si, ax
    jc overflow

next_char:
    xor ah, ah
    int 22

check_digit:
    mov ah, al
    sub al, '0'
    cmp al, 9
    ja digit
    cmp ah, 13
    jnz next_char
    mov ax, si
    test cl, cl
    jz positive
    neg ax

positive:
    jmp word ptr [bx + 4]

test_byte:
    cmp ax, -127
    jl overflow
    cmp ax, 127
    jg overflow
    mov di, [bx + 2]
    mov [di], al
    jmp next_value

overflow:
    mov ah, 9
    lea dx, msg_overflow
    int 33
    mov ax, 4C01h
    int 33

test_word:
    mov di, [bx + 2]
    mov [di], ax

next_value:
    add bx, 6
    cmp bx, InputOrderA[6*4]
    jc input_loop
; Введены все 4 переменные

ADD: Пока на сегодня хватит. Завтра посмотрю на свежую голову.