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

[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_d]
        int 21h
        mov di, offset store_D
        jmp ReadInt16
store_D:
        
        
        mov [d], ax
        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
        
       
 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 plyc
                mov  bx, 1
                cmp bx,1
                je putchar
                plyc:
                cmp al,'+'
                jne @endif
                mov bx,0
                je     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
the_end:
        mov     ax,     4C00h
code ends
end    start

[alonil]

Не получается для вводимых постепенно по символу чисел поставить ограничения,например, у меня три переменные типа байт и одна типа dw нужно поставить ограничения на вводимые числа в рамках этого типа и относительно знакового диапазона чисел,чтобы не выходило за рамки и относительно беззнакового.Помогите,пожалуйста,по ставить такие ограничения.

[macomics]

1) Делаете ввод знаковых чисел длиной до 32-бит.
2) Делаете функции проверки диапазонов для чисел типа db/dw и со знаком/без знака.

input_int32:
    push bp
    mov bp, sp
    xor ax, ax
    push ax ; знак ( = 0 - положительное/без знака)
    push ax ; Начальные значения ...
    push ax ; ... для ввода ( = 0 - 32-бита)
    int 22 ; ah = 0, int 16h - BIOS чтение буфера клавиатуры/ожидание ввода
    mov cx, 10
    cmp al, '-' ; Фиксируем минус в начале ввода
    jnz input_int32_check
    inc byte [bp - 2]

input_int32_loop:
    xor ax, ax
    int 22 ; ah = 0, int 16h - BIOS чтение буфера клавиатуры/ожидание ввода

input_int32_check:
    cmp al, '0'
    jb input_int32_not_digit
    cmp al, '9'
    ja input_int32_not_digit
    sub al, '0'
    mov ah, 0
    xchg ax, [bp - 4]
    mul cx
    add [bp - 4], ax
    adc dx, 0
    mov ax, [bp - 6]
    mov [bp - 6], dx
    mul cx
    add [bp - 6], ax
    adc dx, 0
    jz input_int32_loop

input_int32_error:
; Переполнение буфера числа - выходим и сигнализируем об ошибке (флаг переноса установлен stc)
    or ax, -1
    mov dx, ax
    leave
    stc
    retn

input_int32_not_digit:
; Ввели символ отличный от цифры. Проверим этот символ на завершение ввода:
    cmp al, ' ' ; Клавиша пробела
    jz input_int32_done
    cmp al, 9 ; Клавиша табуляции
    jz input_int32_done
    cmp al, 13 ; Клавиша ввода
    jnz input_int32_error

input_int32_done:
; Ввод числа окончен. Возвращаем результат и сбрасываем флаг ошибки
    test [bp - 2], -1
    jz input_int32_unsigned
    xor ax, ax
    xor dx, dx
    sub ax, [bp - 4]
    sbb dx, [bp - 6]
    jmp input_int32_quit

input_int32_unsigned:
    mov ax, [bp - 4]
    mov dx, [bp - 6]

input_int32_quit:
    leave
    clc
    retn

А вот комплект процедур для разной размерности вводимых чисел с проверкой диапазонов

input_int16:
    call input_int32
    jc input_int16_error ; Вот так можно легко среагировать на флаг ошибки, если функция завершилась неудачно
; Результат работы этой функции записан в паре регистров dx:ax. Чтобы число соответствовало 16-битному диапазону со знаком оно должно укладываться в пределы от -32767 до 32767
    cmp dx, -1
    jz input_int16_ok
    cmp dx, 0
    jnz input_int16_error
    test ah, 10000000b
    jnz input_int16_error

input_int16_ok:
    clc
    retn

input_int16_error:
    stc
    retn



input_uint16:
    call input_int32
    jc input_uint16_error
    cmp dx, 0
    jnz input_uint16_error
    clc
    retn

input_uint16_error:
    stc
    retn



input_int8:
    call input_int16
    jc input_int8_error
    cmp ah, -1
    jz input_int8_ok
    cmp ah, 0
    jnz input_int8_error
    test al, 10000000b
    jnz input_int8_error

input_int8_ok:
    clc
    retn

input_int8_error:
    stc
    retn



input_uint8:
    call input_uint16
    jc input_uint8_error
    cmp ah, 0
    jnz input_uint8_error
    clc
    retn

input_uint8_error:
    stc
    retn

[alonil]

Спасибо большое.

[alonil]

Здравствуйте!Подскажите,пожалуйста, я тут почти сделал,только осталась одна мелочь ,которую у меня е получается записать.Вот если у меня есть две метки и переход к одной из них должен осуществлятся в первый раз, а к другой во все остальные разы.То как это записать?

[alonil]

Я не знаю как это записать.Чтобы это осществить я думал взять какую-то рандомную переменную,с помощью cmp сравнить её с каким-то числом и с помощью команды условного перехода ,чтобы только в первый раз был переход к первой метке.а после не знаю ввести инкримент или что-то такое,чтобы при следующем проходе программы в этом участке такое не работало и написать jmp и указать другую метку и после этого инкримента или чего-то,чтобы оно переходило уже у меня только на вторую метку

[alonil]

Вопрос по поводу строк 140-143.Как это записать?

.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 = ", '$'
        er db 13,10,'Error',13,10,'$'
        a db ?
        b db ?
        c db ?
        d dw ?
        shet db 0
        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:
 Vvod_D:
        mov ah, 09h
        lea dx, [msg_d]
        int 21h
        mov si,offset Vvod_D
        mov di, offset store_D
        jmp ReadInt16
store_D:
        
        
        mov [d], ax
        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
        
       
 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:
        cmp [shet],0
        jz proverka_d
        inc [shet]
        jmp proverka_drygix
      proverka_d:
        test bx,bx
        jz plus_d
        jmp minus_d
      plus_d:  
        cmp cx,32767
        ja error
      minus_d:
      cmp cx,32768
      ja error
      jmp znak
      proverka_drygix:
        test bx,bx
        jz plus_drygie
        jmp minus_drygie
      plus_drygie:
        cmp cx,127
        ja error
        
      minus_drygie:
        cmp cx,128
        ja error
   znak:
        mov  ax, cx
        test bx, bx
        jz  exit
        neg  ax

exit:
        jmp di
error:
        mov ah, 09h
        lea dx, [er]
        int 21h
        jmp Vvod_D
the_end:
        mov     ax,     4C00h
code ends
end    start

[alonil]

_break:
        cmp [shet],0
        jz proverka_d
        inc [shet]
        jmp proverka_drygix

Вот по поводу этих.Как здесь записать,чтобы так работало.

[macomics]

см. пример с метками input_int32_check и input_int32_loop. Обратный пример

cmp al, 1
    jz next_step_code
first_step_code:
    mov al, 1
    jmp end_of_step
next_step_code:
    mov ah, 2
end_of_step:

Простая реализация

if (al != 1) { al = 1; } else { ah = 2; }

ADD: А чем вам не нравится то, что вы написали?

[alonil]

Спасибо!Сейчас попробую.

Как это?Неправильно работает с таким условием.У меня всё-таки не получается подобрать....

Как это?Неправильно работает с таким условием.Вообщем, у меня так и не вышло подобрать правильное условие в этой части... кода ,что я показал отдельно кусочек тот маленький...(