4

16

03106715
03112186
03111423
 DOSBOX
MASM LINK

1
9-bit
2 2 -
. : ' -
DX ( 8-bit DL 1 DH) -
, 2
. hex bit

. flag -
C16 flag persistent
1 (. 11111111C1
6 ).

CODE_SEG SEGMENT
ASSUME CS:CODE_SEG,SS:CODE_SEG,DS:CODE_SEG
ORG 100H

BITSMSG DB "Give a 9-bit 2's complement number: $" ; binary

DECMSG DB "Decimal: $" ;

DEC_DIGITS DB 7 DUP (?)

ADD_ONE PROC NEAR ; D

PUSH DX
PUSH AX
MOV DL,49
MOV AH,2
INT 21H
POP AX
POP DX
SAL DX,1 ; DX
OR DX,0001H ;
RET
ADD_ONE ENDP

ADD_ZERO PROC NEAR ; D

PUSH DX
PUSH AX
MOV DL,48
MOV AH,2
INT 21H
POP AX
POP DX
SAL DX,1 ; DX
AND DX,0FFFEH ;
RET
ADD_ZERO ENDP

; flag BH READ_RY "C16"

READ_BINARY PROC NEAR ;
MOV DX,0 ; DX
MOV BL,0 ; BH "C16" BL
MOV CX,9 ; 9
AGAIN: ; loop
 CMP BL,7 ; 7
JNZ NO_DOT
INC BL ;
PUSH DX
MOV DL,46 ;
MOV AH,2
INT 21H
POP DX
NO_DOT:
MOV AH,8 ;
INT 21H
CMP BH,2 ; flag "C1"
JC CONT ;
CMP AL,54
JNZ CONT2
MOV AX,4C00H ; 6 '
INT 21H
CONT2:
MOV BH,0 ; 6 flag
CONT:
CMP AL,48 ; 0
JNZ NEXT1 ;
CALL ADD_ZERO ; 0 flags 0
INC BL
MOV BH,0
JMP FIN
NEXT1:
CMP AL,49 ; 0
JNZ NEXT2
CALL ADD_ONE ; flags 1
INC BL
CMP BH,1
JC NO_C
INC BH
NO_C:
JMP FIN
NEXT2: ; 'C'
CMP AL,67
JZ NEXT3
MOV BH,0 ; flag
JMP AGAIN ; 0 1 LOOP CX
NEXT3:
MOV BH,1 ; 1 1 string
JMP AGAIN ; 0 1 LOOP CX
FIN:
LOOP AGAIN ; loop CX
RET
READ_BINARY ENDP

START:
MOV AX,CODE_SEG
MOV DS,AX
MOV BX,0
INFLOOP:
LEA DI,DEC_DIGITS
LEA DX,BITSMSG ;
MOV AH,9
INT 21H
CALL READ_BINARY ;
PUSH BX ; BX flag
MOV BX,DX ; DX BX DX DOS
MOV DL,10 ;
MOV AH,2
INT 21H
LEA DX,DECMSG ;
MOV AH,9
INT 21H
TEST BH,01H ;
JZ PLUS_SIGN
 OR BX,0FE00H ; msb 1
NOT BX ; 2
INC BX
MOV DL,45 ; -
MOV AH,2
INT 21H
JMP POSITIVE ; 2
PLUS_SIGN: ; +
MOV DL,43
MOV AH,2
INT 21H
POSITIVE: ;
MOV CX,0A06H ; bits BH
RCL BX,CL
MOV AL,BH
MOV AH,0
DIV CH ; AH AL
ADD AL,48 ; 48 - ASCII
ADD AH,48
CMP AL,48 ; 0 String
JZ ZERO_DEC
MOV BYTE PTR CS:[DI],AL ; ASCII
INC DI
ZERO_DEC:
MOV CS:[DI],AH ; ASCII
INC DI
MOV BYTE PTR CS:[DI],46 ; ASCII
INC DI
MOV AX,03030H ;AL,AH 2 ASCII 0
TEST BL,080H ; 1
JZ NO_50 ; 0 5 1
ADD AH,5 ; 1 2^(-1)=0,5
NO_50:
TEST BL,040H ; 2
JZ NO_25
ADD AH,2 ; 1 2^(-2)=0,25 2
ADD AL,5 ; 5
NO_25:
MOV BYTE PTR CS:[DI],AH ; string
INC DI
MOV BYTE PTR CS:[DI],AL ; string
MOV BYTE PTR CS:[DI+1],10 ;
MOV BYTE PTR CS:[DI+2],36 ; string $
LEA DX,DEC_DIGITS ; DOS string
MOV AH,9
INT 21H
POP BX ; flag string
JMP INFLOOP ;

CODE_SEG ENDS
END START
 2

3-
.
array AX
packed ( )
( 1000 100 ...).

CODE_SEG SEGMENT
ASSUME CS:CODE_SEG,SS:CODE_SEG,DS:CODE_SEG
ORG 100H

HEXMSG DB "GIVE 3 HEX DIGITS: $" ;

DECIMALMSG DB "Decimal= $"

OUTPUT DB 3 DUP (?) ; hex

READ_HEX PROC NEAR ;

LEA DI,OUTPUT ; array
MOV CX,3 ; 3
AGAIN: ; 'U' hex
MOV AH,8 ;
INT 21H
CMP AL,58 ;
JNC NO_DIGIT ; 58
CMP AL,48
JC AGAIN ; CL
MOV DL,AL ;
MOV AH,2
INT 21H
SUB AL,48 ; 48
JMP FIN ; CL
NO_DIGIT: ; 'U'
CMP AL,71 ; A-F
JNC NO_LETTER ; 'U'
CMP AL,65 ; -F
JC AGAIN ; A-F CL
MOV DL,AL ;
MOV AH,2
INT 21H
SUB AL,55 ; (=10... )
JMP FIN ; CL
NO_LETTER: ;
CMP AL,85
JNZ AGAIN
MOV AX,4C00H ; 'U' '
INT 21H
FIN: ;
STOSB ;
LOOP AGAIN
WAIT_ENTER: ; ENTER
MOV AH,8
INT 21H
CMP AL,85 ; U
JNZ NO_U
MOV AX,4C00H
INT 21H
NO_U: ; U ENTER
CMP AL,13
 JNZ WAIT_ENTER
MOV DL,10 ;
MOV AH,2
INT 21H
RET
READ_HEX ENDP

COMPUTE_NUMBER PROC NEAR ; '

MOV CH,DS:[OUTPUT] ; 1 hex 4 lsb CH
MOV CL,DS:[OUTPUT+1] ; 2 hex 4 msb CL
RCL CL,1
RCL CL,1
RCL CL,1
RCL CL,1
AND CL,0F0H
MOV AL,DS:[OUTPUT+2] ; 3 hex 4 lsb CL
ADD CL,AL
RET
COMPUTE_NUMBER ENDP

PRINT_DECIMAL PROC NEAR ;

MOV DX,0 ; DX word AX
CMP AX,10 ; '
JC MONADES
CMP AX,100
JC DEKADES
CMP AX,1000
JC EKATONTADES
COMPUTE_K: ;
MOV CX,1000 ; 1000:
DIV CX
MOV BX,DX ; DX
MOV DL,AL ;
ADD DL,48
MOV AH,2
INT 21H
MOV DL,44 ;
MOV AH,2
INT 21H
MOV AX,BX ; AX
EKATONTADES: ;
MOV CL,100 ; 100
DIV CL
MOV BL,AH
MOV DL,AL
ADD DL,48
MOV AH,2 ;
INT 21H
MOV AL,BL
MOV AH,0
DEKADES: ;
MOV CL,10 ; 10
DIV CL
MOV BL,AH
MOV DL,AL
ADD DL,48 ;
MOV AH,2
INT 21H
MOV AL,BL
MONADES: ;
MOV DL,AL ;
ADD DL,48
MOV AH,2
INT 21H
RET
PRINT_DECIMAL ENDP

START:
MOV AX,CODE_SEG
MOV DS,AX
INFLOOP: ;
LEA DX,HEXMSG ;
MOV AH,9
INT 21H
CALL READ_HEX ; hex
CALL COMPUTE_NUMBER ; hex CX
LEA DX,DECIMALMSG ;
MOV AH,9
INT 21H
MOV AX,CX
CALL PRINT_DECIMAL ;
MOV DL,10 ;
MOV AH,2
INT 21H
JMP INFLOOP

CODE_SEG ENDS
END START
 3

3 16
, ,
,
2
. :
( )
(1 ,1 1 )
.

2
. 1 2
BH, BL
BH,BL .

CODE_SEG SEGMENT
ASSUME CS:CODE_SEG,SS:CODE_SEG,DS:CODE_SEG
ORG 100H

KEFALAIA DB 17 DUP (?)

MIKRA DB 17 DUP (?)
DIGITS DB 17 DUP (?)
OFFSETS DB 6 DUP(0)

PRINT_CHARACTER PROC NEAR

MOV DL,AL
MOV AH,2
INT 21H
RET
PRINT_CHARACTER ENDP

CLEAR_ARRAYS PROC NEAR ; ' offsets

LEA BP,KEFALAIA
MOV DI,0
MOV CX,17
LOOPA1: ; 0
MOV BYTE PTR DS:[BP+DI],0
INC DI
LOOP LOOPA1
LEA BP,MIKRA
MOV DI,0
MOV CX,17
LOOPA2:
MOV BYTE PTR DS:[BP+DI],0
INC DI
LOOP LOOPA2
LEA BP,DIGITS
MOV DI,0
MOV CX,17
LOOPA3:
MOV BYTE PTR DS:[BP+DI],0
INC DI
LOOP LOOPA3
MOV [KEFALAIA],36 ; strinh '$'
MOV [MIKRA],36
MOV [DIGITS],36
 MOV [OFFSETS],0 ; offsets
MOV [OFFSETS+1],0
MOV [OFFSETS+2],0
RET
CLEAR_ARRAYS ENDP

READ_KEY PROC NEAR ; arrays

LEA BP,KEFALAIA ; bp
MOV DS:[OFFSETS+2],17 ; offset 17 array 17
MOV DS:[OFFSETS+4],34 ; offset 34 array 34
MOV CX,16 ; loop 16
AGAIN: ;loop
MOV AH,8 ; '
INT 21H
CMP AL,13 ; ENTER loop
JZ ENTER_PRESSED
CMP AL,58 ; '*'
JNC NOT_DIGIT
CMP AL,48 ;
JC CHECK_SPACE ; '*'
CALL PRINT_CHARACTER ;
MOV DI,WORD PTR CS:[OFFSETS+4] ; offset
MOV DS:[BP+DI],DL
INC DI ; offset
MOV WORD PTR CS:[OFFSETS+4],DI ; offset offset
JMP FIN ; CX
CHECK_SPACE: ; CX
CMP AL,32
JNZ CHECK_STAR
CALL PRINT_CHARACTER
JMP FIN
CHECK_STAR: ;
CMP AL,42
JNZ AGAIN ; '*' CX
MOV AX,4C00H ; '*' '
INT 21H
NOT_DIGIT: ;
CMP AL,91 ;
JNC NOT_CAPITAL ;
CMP AL,65 ;
JC AGAIN ; CX
CALL PRINT_CHARACTER ;
MOV DI,WORD PTR CS:[OFFSETS] ; offset
MOV DS:[BP+DI],DL
INC DI ; offset
MOV WORD PTR CS:[OFFSETS],DI ; offset offset
JMP FIN ; CX
NOT_CAPITAL: ;
CMP AL,97
JC AGAIN ; CX
CMP AL,123
JNC AGAIN ; CX
CALL PRINT_CHARACTER ;
MOV DI,WORD PTR CS:[OFFSETS+2] ; offset
MOV DS:[BP+DI],DL
INC DI ; offset
MOV WORD PTR CS:[OFFSETS+2],DI ; offset offset
FIN:
LOOP AGAIN ;
WAIT_ENTER: ; 16 ENTER
MOV AH,8
INT 21H
CMP AL,42 ; '
JZ CHECK_STAR
CMP AL,13 ; ENTER
JNZ WAIT_ENTER ; ENTER ENTER
ENTER_PRESSED: ; ENTER
MOV DL,10 ;
MOV AH,2
INT 21H
 MOV DI,WORD PTR CS:[OFFSETS] ; string
MOV WORD PTR DS:[BP+DI],36
MOV DI,WORD PTR CS:[OFFSETS+2]
MOV WORD PTR DS:[BP+DI],36
MOV DI,WORD PTR CS:[OFFSETS+4]
MOV WORD PTR DS:[BP+DI],36
RET
READ_KEY ENDP

FIND_SMALLEST_DIGITS PROC NEAR ; 2

LEA BP,DIGITS ;
MOV BL,CS:[BP] ; BL
MOV DI,2 ; ' 2
CMP BL,36 ; 0
JNZ CONT1 ;
MOV DL,10 ;
MOV AH,2
INT 21H
RET
CONT1: ; 1
MOV BH,CS:[BP+1] ; BH ( '$')
CMP BH,36 ;
JNZ CONT2
MOV AL,BL ; 1
CALL PRINT_CHARACTER
MOV AL,10
CALL PRINT_CHARACTER
RET
CONT2: ; 2
MOV CL,CS:[BP+DI] ; CL
CMP CL,36 ; '$'
JZ FINNISH ; '$' ' , BL BH
CMP BL,BH ; 2
JC MIN1_MIN2
CMP CL,BL ; BH BL
JGE NEXT
MOV BL,BH ; 2 BH CL
MOV BH,CL
JMP NEXT ;
MIN1_MIN2: ; BL B
CMP CL,BH
JGE NEXT
MOV BH,CL ; 2 BL CL
NEXT:
INC DI ;
JMP CONT2
FINNISH: ; 2
MOV AL,BL
CALL PRINT_CHARACTER
MOV AL,BH
CALL PRINT_CHARACTER
MOV AL,10
CALL PRINT_CHARACTER
RET
FIND_SMALLEST_DIGITS ENDP

START:
MOV AX,CODE_SEG
MOV DS,AX
INFLOOP: ;
CALL CLEAR_ARRAYS ; offsets
CALL READ_KEY ;
LEA DX,KEFALAIA ;
MOV AH,9
INT 21H
MOV AL,45 ;
CALL PRINT_CHARACTER
LEA DX,MIKRA ;
MOV AH,9
INT 21H
 MOV AL,45 ;
CALL PRINT_CHARACTER
LEA DX,DIGITS ;
MOV AH,9
INT 21H
MOV DL,10 ;
MOV AH,2
INT 21H
CALL FIND_SMALLEST_DIGITS ; 2
JMP INFLOOP ;
CODE_SEG ENDS
END START