ROVA PRATICA #1

;Esempio:l'utente batte

prova di scrittura. Batto<CR>QUIT e poi da QUIT<CR>

il programma scrive su video

Giunta Pisano numero di matricola 000001

prova [prova] di [di] scrittura. [scrittura.] Batto 838f53i

[Batto] QUIT [QUIT] e [e] poi [poi] da [da] QUIT

INCLUDE compatib

INCLUDE utility

mystack SEGMENT STACK

BYTE 1024 DUP(?)

mystack ENDS

mydata SEGMENT

MESS BYTE 'Paolo Corsini # di matricola 000002',0AH, 0DH

mydata  ENDS

mycode  SEGMENT 'CODE'

ASSUME ES:SELECTOR mydata

eco PROC NEAR

MOV AL,'['

CALL OUTPUT

SUB DI,SI

MOV CX,DI

MOV BX,SI

MOV DI,SI

CALL OUTMESS

MOV AL,']'

CALL OUTPUT

MOV AL,' '

CALL OUTPUT

RET

eco ENDP

ver PROC NEAR

PUSH DI

MOV DI,SI

CMP BY ES:[DI],'Q'

JNE fine

INC DI

CMP BY ES:[DI],'U'

JNE fine

INC DI

CMP BY ES:[DI],'I'

JNE fine

INC DI

CMP BY ES:[DI],'T'

JNE fine

MOV BX,0FABH

JMP fine

fine: POP DI

RET

ver ENDP

main PROC FAR

MOV AX,SELECTOR mydata

MOV ES,AX

MOV DX,ES

MOV BX,OFFSET MESS

CALL NEWLINE

CALL OUTLINE

MOV SI,24H

MOV DI,SI

MOV AX,0

MOV BX,0

start:  CALL INPUT

CMP AL,32H

JB lab1

CMP AL,7FH

JE start

MOV ES:[DI],AL

INC DI

CALL OUTPUT

JMP start

lab1: CMP AL,20H

JE spazio

CMP AL,0DH

JNE start

CALL ver

CMP BX,0FABH

JE uscita

CALL OUTPUT  

MOV AL,0AH

CALL OUTPUT

CALL eco

JMP start

spazio: CALL OUTPUT

CALL eco

JMP start

uscita: .EXIT

main ENDP

mycode ENDS

END main

;PROVA PRATICA #2

;Scrivere un programma che, partendo da uno stato iniziale in cui n=20

;esegue ciclicamente le seguenti azioni:

;1) legge un carattere c

- se c='q' termina;

- se c='l' e n>0 decrementa n;

- se c='r' e n<40 incrementa n;

- negli altri casi lascia n immutato.

;2) se n=0  stampa "|BONG...... 37 .......|"

se n=40 stampa "|........ 37 .....BONG|"

altrimenti "|.. n ...0... 40-n ...|"

INCLUDE compatib

INCLUDE utility

mystack SEGMENT STACK

BYTE 1024 DUP(?)

mystack ENDS

mydata  SEGMENT

N BYTE 14H

MESS1 BYTE '|BONG...... 37 .......|', 0DH,0AH

MESS2 BYTE '|........ 37 .....BONG|', 0DH,0AH

HEAD BYTE '|.. '

BODY BYTE ' ...0... '

FOOT BYTE ' ...|'

mydata  ENDS

mycode  SEGMENT 'CODE'

ASSUME ES:SELECTOR mydata

main PROC FAR

MOV AX, SELECTOR mydata

MOV ES, AX

start:  CALL INPUT

CMP AL,71H

JZ quit

CMP AL,72H

JZ incr

CMP AL,6CH

JZ decr

JMP print

decr: CMP N,0

JBE print

DEC N

JMP print

incr: CMP N,28H

JAE print

INC N

JMP print

print:  MOV DX,ES

MOV AX,0

CALL NEWLINE

CMP N,0

JZ msg1

CMP N,28H

JZ msg2

MOV BX,OFFSET HEAD

MOV CX,4

CALL OUTMESS

MOV AL,N

MOV CX,2

CALL B16DAN_out

MOV BX,OFFSET BODY

MOV CX,9

CALL OUTMESS

MOV AL,28H

SUB AL,N

MOV CX,2

CALL B16DAN_out

MOV BX,OFFSET FOOT

MOV CX,5

CALL OUTMESS

JMP start

msg1: MOV BX,OFFSET MESS1

CALL OUTLINE

JMP start

msg2: MOV BX,OFFSET MESS2

CALL OUTLINE

JMP start

quit: .EXIT

main ENDP

mycode ENDS

END main

;PROVA PRATICA #3

;Scrivere un programma che simula il sommatore modulare per numeri

;naturali a 6 cifre in base dieci. Il programma deve eseguire ciclicamente

;le seguenti operazioni

;1) leggere da tastiera X e Y su 6 cifre in base 10, e C0 su una cifra

;in base 2, facendo gli opportuni controlli;

;2) stampare X, Y, il risultato Z=X+Y e i riporti intermedi Ci

;3) termina quando il risulato vale 616460

INCLUDE  compatib

INCLUDE  utility

mystack SEGMENT STACK

BYTE 400H DUP (?)

mystack ENDS

mydata  SEGMENT

MESS1 BYTE 'Inserisci X: 6 cifre in base 10',0AH,0DH

MESS2 BYTE 'Inserisci Y: 6 cifre in base 10',0AH,0DH

MESS3 BYTE 'Inserisci il riporto C0: 0 o 1?',0AH,0DH

MESS4 BYTE 'X+Y= '

MESS5 BYTE 'I riporti intermedi C6 .. C1 sono',0AH,0DH

C0 BYTE ?

NUMX BYTE 6 DUP (?)

NUMY BYTE 6 DUP (?)

SOMMA BYTE 6 DUP (0)

RIPORTI BYTE 6 DUP (0)

mydata  ENDS

mycode  SEGMENT 'CODE'

ASSUME ES:SELECTOR mydata

somme PROC NEAR

MOV SI,6

ripeti: ADD AL,NUMX[SI-1]

ADD AL,NUMY[SI-1]

CMP AL,0AH

JAE go

ADD AL,30H

MOV SOMMA[SI-1],AL

JMP cifra

go: SUB AL,10D

ADD AL,30H

MOV SOMMA[SI-1],AL

MOV RIPORTI[SI-1],1

JMP step

cifra: MOV RIPORTI[SI-1],0

step: MOV AL,RIPORTI[SI-1]

DEC SI

JNZ ripeti

RET

somme ENDP

stampa  PROC NEAR

MOV BX,OFFSET MESS4

MOV CX,5

CALL OUTMESS

MOV SI,0

still: MOV AL,SOMMA[SI]

CALL OUTPUT

INC SI

CMP SI,6

JNZ still

CALL NEWLINE

MOV BX,OFFSET MESS5

CALL OUTLINE

MOV SI,0

ancora: MOV AL,RIPORTI[SI]

ADD AL,30H

CALL OUTPUT

INC SI

CMP SI,6

JNZ ancora

RET

stampa  ENDP

ver PROC NEAR

MOV AL,RIPORTI[0]

CMP AL,0

JNZ fine

MOV AL,SOMMA[0]

CMP AL,'6'

JNZ fine

MOV AL,SOMMA[1]

CMP AL,'1'

JNZ fine

MOV AL,SOMMA[2]

CMP AL,'6'

JNZ fine

MOV AL,SOMMA[3]

CMP AL,'4'

JNZ fine

MOV AL,SOMMA[4]

CMP AL,'6'

JNZ fine

MOV AL,SOMMA[5]

CMP AL,'0'

JNZ fine

MOV AL,'Y'

fine: RET

ver ENDP

main PROC FAR

MOV AX,SELECTOR mydata

MOV ES,AX

start:  CALL NEWLINE

MOV DX,ES

MOV BX,OFFSET MESS1

CALL OUTLINE

MOV SI,0

cicl0: CALL inDA1_eco

SUB AL,30H

MOV NUMX[SI],AL

INC SI

CMP SI,6

JNZ cicl0

CALL NEWLINE

MOV BX,OFFSET MESS2

CALL OUTLINE

MOV SI,0

cicl1: CALL inDA1_eco

SUB AL,30H

MOV NUMY[SI],AL

INC SI

CMP SI,6

JNZ cicl1

CALL NEWLINE

MOV BX,OFFSET MESS3

CALL OUTLINE

ciclo:  CALL INPUT

CMP AL,'0'

JB ciclo

CMP AL,'1'

JA ciclo

CALL OUTPUT

CALL NEWLINE

SUB AL,30H

CALL somme

CALL stampa

CALL ver

CMP AL,'Y'

JNZ start

.EXIT

main  ENDP

mycode  ENDS

END main

;PROVA PRATICA #4

;Simulare un processore dotato di un registro ad 8 bit (R0), program

;counter ad 8 bit e 256 bytes di memoria e in grado di eseguire le

;seguenti istruzioni

;opcode  mnemonico descrizione

CLR azzera il registro R0

;01 n    ADD n somma al registro un intero n su 8

bit in complemento a 2

PRINT stampa su video il contenuto di R0

in decimale seguito da CR e LF

;03 addr JNZ addr salta all'indirizzo addr se R0 È diverso da 0

HALT ferma il processore simulato

;Programmare il processore simulato per far eseguire il seguente programma

;(in linguaggio macchia, da caricare nella memoria simulata a partire

;dall'indirizzo 0):

;00h 01h 20h 02h 01h 0FFh 03h 03h 04h

INCLUDE compatib

INCLUDE utility

mystack SEGMENT STACK

BYTE 1024 DUP(?)

mystack ENDS

mydata  SEGMENT

R0 BYTE ?

MESS1 BYTE 'INVALID OPCODE',0AH,0DH

MESS2 BYTE 'R0='

MARK LABEL BYTE

mydata  ENDS

mycode  SEGMENT 'CODE'

ASSUME ES:SELECTOR mydata

main PROC FAR

MOV AX,SELECTOR mydata

MOV ES,AX

MOV SI,OFFSET MARK

MOV BY ES:[SI],00H   ;Carico il programma in memoria

MOV BY ES:[SI+1],01H

MOV BY ES:[SI+2],20H

MOV BY ES:[SI+3],02H

MOV BY ES:[SI+4],01H

MOV BY ES:[SI+5],0FFH

MOV BY ES:[SI+6],03H

MOV BY ES:[SI+7],03H

MOV BY ES:[SI+8],04H

MOV BX,0

start:  MOV AL,ES:[SI+BX]

INC BX

CMP AL,00H

JZ clr

CMP AL,01H

JZ somma

CMP AL,02H

JZ stampa

CMP AL,03H

JZ salto

CMP AL,04H

JZ stop

MOV DX,ES

PUSH BX

MOV BX,OFFSET MESS1

CALL OUTLINE

POP BX

JMP stop

clr: MOV R0,00H

JMP start

somma:  MOV CL,ES:[SI+BX]

INC BX

ADD R0,CL

JMP start

stampa: MOV DX,ES

PUSH BX

MOV BX,OFFSET MESS2

MOV CX,3

CALL OUTMESS

POP BX

MOV AH,0

MOV AL,R0

AND AL,10000000b

JNZ nega

MOV AL,R0

MOV CX,3

CALL B16DAN_out

CALL NEWLINE

JMP start

nega: MOV AL,2DH

CALL OUTPUT

MOV AL,R0

NOT AL

INC AL

MOV CX,3

CALL B16DAN_out

CALL NEWLINE

JMP start

salto: CMP R0,0

JZ start

MOV AL,ES:[SI+BX]

MOV BL,AL

JMP start

stop: .EXIT

main ENDP

mycode  ENDS

END main

;PROVA PRATICA #5

;Scrivere un programma che si comporta come segue:

;1) legge da tastiera un numero natura N su due cifre in base 5,

facendo gli opportuni controlli sulle cifre accettate;

;2) stampa la riga

(XX)5 = (YY)10 [+++++++++++++++++]

dove XX È il numero N espresso in base 5, YY su base 10

e il numero di caratteri '+' È pari ad N

;3) se N=0 termina, altrimenti torna al passo 1

INCLUDE compatib

INCLUDE utility

mystack SEGMENT STACK

BYTE 1024 DUP(?)

mystack ENDS

mydata  SEGMENT

mydata  ENDS

mycode  SEGMENT 'CODE'

ASSUME DS:SELECTOR mydata

main PROC FAR

MOV AX,SELECTOR mydata

MOV DS,AX

MOV AX,0

start0: CALL input

CMP AL,30H

JB start0

CMP AL,34H

JA start0

CALL output

MOV DH,AL

start1: CALL input

CMP AL,30H

JB start1

CMP AL,34H

JA start1

CALL output

CALL newline

MOV DL,AL

MOV AL,'('

CALL output

MOV AL,DH

CALL output

MOV AL,DL

CALL output

MOV AL,')'

CALL output

MOV AL,'5'

CALL output

MOV AL,'='

CALL output ;(xx)5=

MOV AL,DL

CALL HA1B4

MOV DL,AL

MOV AL,DH

CALL HA1B4

MOV CL,05H

MUL CL

ADD DL,AL

MOV AL,28H

CALL output

MOV AL,DL

MOV CX,2

CALL B16DAN_out

MOV AL,29H

CALL output

MOV AL,31H

CALL output

MOV AL,30H ;(yy)10

CALL output

MOV AL,20H

CALL output

MOV AL,5BH

CALL output

CMP DL,0

JZ fine

MOV AL,2BH

ciclo:  CALL output

DEC DL

JNZ ciclo

MOV AL,5DH

CALL output

CALL newline

JMP start0

fine: MOV AL,5DH

CALL output

.EXIT

main ENDP

mycode ENDS

END main

;PROVA PRATICA #6

;Scrivere un programma che esegue ciclicamente le seguenti azioni:

;1) legge da tastiera la rappresentazione, in complemento, su 3 cifre

in base 8, del numero intero a

;2) disegna sullo schermo un rettangolo pieno di

larghezza = 5 + ABS(a)/10

altezza = 4 + [ABS(a) modulo 10]

usando il carattere "+" se a>=0, "-" se a<0

INCLUDE compatib

INCLUDE utility

mystack SEGMENT STACK

BYTE 400H DUP (?)

mystack ENDS

mydata  SEGMENT

MESS BYTE 'Inserisci un numero su tre cifre in base 8',0AH,0DH

BUFF BYTE 3 DUP (?)

ABS WORD 0

LARG WORD 5

ALTZ WORD 4

SEGNO BYTE ?

mydata  ENDS

mycode  SEGMENT 'CODE'

ASSUME DS:SELECTOR mydata

indata PROC NEAR

MOV SI,0

start:  CALL INPUT

CMP AL,'0'

JB start

CMP AL,'7'

JA start

CALL OUTPUT

MOV BUFF[SI],AL

INC SI

CMP SI,3

JNE start

MOV AL,BUFF[2] ;CONVERSIONE DA 3 ASCII A 3 CIFRE IN BASE 8

SUB AL,30h

MOV CX,1d

MUL CL

ADD ABS,AX

MOV AL,BUFF[1]

SUB AL,30h

MOV CX,8d

MUL CL

ADD ABS,AX

MOV AL,BUFF[0]

SUB AL,30h

MOV CX,64d

MUL CL

ADD ABS,AX

CMP BUFF[0],'4'

JB pos

MOV SEGNO,'-' ;RICAVO IL VALORE ASSOLUTO SE NUM<0

MOV AX,ABS

ADD AX,0FE00H

NEG AX

MOV ABS,AX

JMP fine

pos: MOV SEGNO,'+'

fine: RET

indata ENDP

stampa  PROC NEAR

CALL NEWLINE

MOV AL,SEGNO

MOV BX,LARG

MOV CX,ALTZ

ripeti: CALL OUTPUT

DEC BX

JNZ ripeti

CALL NEWLINE

DEC CX

MOV BX,LARG

JNZ ripeti

RET

stampa  ENDP

main PROC FAR

MOV AX,SELECTOR mydata

MOV DS,AX

MOV DX,DS

MOV BX,OFFSET MESS

CALL OUTLINE

CALL indata

MOV DX,0

MOV AX,ABS

MOV BX,0AH

DIV BX

ADD LARG,AX

ADD ALTZ,DX

CALL stampa

.EXIT

main  ENDP

mycode  ENDS

END   main

;PROVA PRATICA #7

;Scrivere un programma che si comporta come segue:

;1) legge da tastiera un numero naturale su tre cifre in base tre,

assegnandone il valore alla variabile LATO;

;2) legge da tastiera un carattere minuscolo che rappresenta una vocale;

;3) disegna un rettangolo pieno di larghezza LATO e altezza LATO/2

utilizzando la vocale letta in precedenza;

;4) legge un carattere da tastiera accetando solo: '+', '-' e 'q';

;5) se il carattere letto È 'q' termina;

;6) se il carattere letto È '+' o '-' incrementa o decrementa la variabile

LATO (mantenedone per. 5<=LATO<=40) e torna al passo 3

INCLUDE compatib

INCLUDE utility

mystack SEGMENT STACK

BYTE 1024 DUP (?)

mystack ENDS

mydata SEGMENT

MESS1 BYTE 'Inserisci un # di 3 cifre in base 3',0DH,0AH

MESS2 BYTE 'Dammi una vocale...',0DH,0AH

VETT BYTE 3 DUP (?)

LATO BYTE ?

VOC BYTE ?

mydata  ENDS

mycode  SEGMENT 'CODE'

ASSUME DS:SELECTOR mydata

conv PROC NEAR

CMP AL,'0'

JZ zero

CMP AL,'1'

JZ uno

CMP AL,'2'

JZ due

zero: MOV AL,0000

JMP fine

uno: MOV AL,0001

JMP fine

due: MOV AL,0002

fine: RET

conv ENDP

main PROC FAR

MOV AX,SELECTOR mydata

MOV DS,AX

MOV DX,DS

start0: CALL NEWLINE

MOV BX,OFFSET MESS1

CALL OUTLINE

CALL NEWLINE

MOV DI,3

start:  CALL INPUT

CMP AL,30H

JB start

CMP AL,32H

JA start

CALL OUTPUT

MOV VETT[DI-1],AL

DEC DI

JNZ start

MOV AX,0

MOV AL,VETT[0]

CALL conv

MOV LATO,AL

MOV AL,VETT[1]

CALL conv

MOV CX,3

MUL CL

ADD LATO,AL

MOV AL,VETT[2]

CALL conv

MOV CX,9

MUL CL

ADD LATO,AL

CMP LATO,0

JZ start0

CMP LATO,1

JZ start0

CALL NEWLINE

MOV BX,OFFSET MESS2

CALL OUTLINE

CALL NEWLINE

vocale: CALL INPUT

CMP AL,'a'

JZ ok

CMP AL,'e'

JZ ok

CMP AL,'i'

JZ ok

CMP AL,'o'

JZ ok

CMP AL,'u'

JNZ vocale

ok: MOV VOC,AL

stampa: CALL NEWLINE

MOV CL,LATO

MOV AL,LATO

MOV AH,0

MOV BL,2

DIV BL

MOV BL,AL

MOV AL,VOC

goon: CALL OUTPUT

DEC CL

JNZ goon

CALL NEWLINE

DEC BL

MOV CL,LATO

JNZ goon

ingr: CALL INPUT

CMP AL,'q'

JZ fine

CMP AL,'+'

JZ incr

CMP AL,'-'

JZ decr

JMP ingr

decr: CMP LATO,5

JZ stmp1

DEC LATO

stmp1: JMP stampa

incr: CMP LATO,40

JZ stmp2

INC LATO

stmp2:  JMP stampa

fine: .EXIT

main ENDP

mycode  ENDS

END main

;PROVA PRATICA #8

;Scrivere un programma che:

;1. legge da tastiera, con eco, una stringa di max 40 caratteri,

terminata da un ritorno carrello

;2. su una nuova linea stampa la stringa sostituendo ai caratteri

di posizione PARI il carattere '_' (underscore)

;3. su una nuova linea stampa la stringa sostituendo ai caratteri

di posizione DISPARI il carattere ' ' (spazio)

;4. se la stringa battuta inizia con 'FINE' termina, altrimenti

torna al punto 1.

INCLUDE compatib

INCLUDE utility

mystack    SEGMENT STACK

BYTE 512 DUP (?)

mystack    ENDS

mydata SEGMENT

vett   BYTE 42 DUP (?)

mydata ENDS

mycode SEGMENT 'CODE'

ASSUME DS:SELECTOR mydata

main   PROC FAR

MOV AX,SELECTOR mydata

MOV DS,AX

chiama: MOV DX,DS ;Prende la stringa di caratteri

MOV BX,OFFSET vett

MOV CX,42

CALL inline_eco

MOV DI,0

ciclo: CMP vett[DI],0DH

JE avanti

INC DI

JMP ciclo

avanti: DEC DI

MOV SI, 0

MOV CX, DI

pari:  MOV AL, vett[SI]

CALL output

INC SI

DEC CX

JZ sotto

MOV AL,' '

CALL output

INC SI

DEC CX

JNZ pari

sotto: CALL newline

MOV SI,1

dispari: MOV AL, ' '

CALL output 

MOV AL,vett[SI]

CALL output

ADD SI,2

CMP SI,DI

JB dispari

CALL newline

;Controlla se la stringa e' 'FINE'

CMP vett[0],'F'

JNE chiama

CMP vett[1],'I'

JNE chiama

CMP vett[2],'N'

JNE chiama

CMP vett[3],'E'

JNE chiama

.EXIT

main   ENDP

mycode ENDS

END main

;PROVA PRATICA #9

;Scrivere un programma che:

;1) legge da tastiera un numero su quattro cifre in base due, che costituisce

la rappresentazione in complemento a 2 su quattro cifre di un intero

relativo "a";

;2) stampa il valore di a in base 10, in modulo e segno;

;3) se a>0 stampa una striscia lunga a di asterischi "*";

;4) se a<0 stampa una striscia lunga -a di cancelletti "#";

;5) se a=0 termina, altrimenti torna al passo 1

INCLUDE compatib

INCLUDE utility

mystack SEGMENT STACK

BYTE 400H DUP (?)

mystack ENDS

mydata  SEGMENT

MESS0 BYTE 'Inserisci un numero su 4 cifre in base 2 in c.r.',0AH,0DH

NUM BYTE 4 DUP (?)

A BYTE ?

SEGNO BYTE ?

mydata ENDS

mycode  SEGMENT 'CODE'

ASSUME DS:SELECTOR mydata

indata PROC NEAR

MOV SI,OFFSET NUM

MOV BX,0

start:  CALL INPUT

CMP AL,'0'

JB start

CMP AL,'1'

JA start

CALL OUTPUT

MOV NUM[SI+BX],AL

INC BX

CMP BX,4

JNE start

RET

indata ENDP

conver PROC NEAR

MOV CL,8

MOV SI,OFFSET NUM

MOV BX,0

MOV AL,NUM[SI+BX]

CMP AL,'1'

JE nega

posi: SHR CL,1

INC BX

CMP BX,4

JE fine

MOV AL,NUM[SI+BX]

CMP AL,'1'

JNE posi

ADD A,CL

JMP posi

nega: SHR CL,1

INC BX

CMP BX,4

JE fine

MOV AL,NUM[SI+BX]

CMP AL,'0'

JNE nega

ADD A,CL

JMP nega

fine: MOV AL,NUM[SI]

CMP AL,'1'

JNE bye1

INC A

MOV SEGNO,'-'

JMP bye2

bye1: MOV SEGNO,'+'

bye2: RET

conver  ENDP

stampa  PROC NEAR

CALL NEWLINE

MOV AL,SEGNO

CALL OUTPUT

MOV AX,0

MOV AL,A

CMP AL,0

JE via

MOV CX,1

CALL B16DAN_out

MOV CL,AL

CALL NEWLINE

CMP SEGNO,'+'

JE ast

canc: MOV AL,'#'

JMP ciclo

ast: MOV AL,'*'

ciclo:  CALL OUTPUT

DEC CX

JNZ ciclo

via: RET

stampa ENDP

main PROC FAR

MOV AX,SELECTOR mydata

MOV DS,AX

beg: MOV A,0

MOV DX,DS

MOV BX,OFFSET MESS0

CALL NEWLINE

CALL OUTLINE

CALL INDATA

CALL NEWLINE

CALL CONVER

CALL STAMPA

CMP AL,0

JNE beg

.EXIT

main ENDP

mycode ENDS

END main

;PROVA PRATICA #10

;Scrivere un programma che simuli l'unità descritta come segue:

;x:  4 bit varible

;A,B,D:  4 bit registers

;ror(4 bit): 4 bit produced

;RST: A:=1; B:=2; D:=3

;L0: A:=x; B:=ror(A); D:=ror(x);

; goto

;L1: B:=D; D:=ror(A);

; goto

;All'avvio del programma l'unità si porta nello stato di reset.

;Da tastiera si batte una cifra esadecimale "x" seguita da CR che

;rappresenta il clock.

;Il circuito risponde stampando il contenuto di STAR, A, B, D

;dopo il clock

INCLUDE compatib

INCLUDE utility

mystack SEGMENT STACK

BYTE 1024 DUP(?)

mystack ENDS

mydata  SEGMENT

RegA BYTE ?

RegB BYTE ?

RegD BYTE ?

BUFF BYTE ?

MJR BYTE 0

MJROLD BYTE 0

MESS0 BYTE 'Inserisci x',0DH,0AH

MESS1 BYTE 'STAR:= '

MESS2 BYTE 'A= '

MESS3 BYTE 'B= '

MESS4 BYTE 'D= '

mydata  ENDS

mycode  SEGMENT 'CODE'

ASSUME ES:SELECTOR mydata

indata PROC NEAR

MOV DX,ES

MOV BX,OFFSET MESS0

CALL OUTLINE

CALL NEWLINE

MOV BUFF,0

MOV CX,4

MOV DX,8

begin:  CALL INPUT

CMP AL,'0'

JZ ok

CMP AL,'1'

JNZ begin

ok: CALL OUTPUT

CALL HA1B4

MUL DL

SHR DL,1

ADD BUFF,AL

DEC CX

JNZ begin

CALL NEWLINE

RET

indata ENDP

ctrl PROC NEAR

PUSH AX

MOV AL,MJR

MOV MJROLD,AL

MOV BL,RegB

MOV DL,RegD

CMP BL,DL

JNZ mjr1

MOV MJR,0

JMP fine

mjr1: MOV MJR,1

fine: POP AX

RET

ctrl ENDP

bin_out PROC NEAR

PUSH CX

MOV CX,4

SHL AL,1

SHL AL,1

SHL AL,1

SHL AL,1

SHL AL,1

JNC zero

JMP uno

still: SHL AL,1

JNC zero

uno: PUSH AX

MOV AL,'1'

CALL OUTPUT

POP AX

DEC CX

JZ bye

JMP still

zero: PUSH AX

MOV AL,'0'

CALL OUTPUT

POP AX

DEC CX

JZ bye

JMP still

bye: POP CX

RET

bin_out ENDP

stmp PROC NEAR

PUSH AX

PUSH BX

PUSH CX

PUSH DX

more: CALL INPUT

CMP AL,0DH

JNZ more

MOV DX,ES

MOV BX,OFFSET MESS1

MOV CX,7

CALL OUTMESS

MOV AL,'L'

CALL OUTPUT

CMP MJROLD,0

JZ stmpL0

stmpL1: MOV AL,'1'

CALL OUTPUT

JMP regs

stmpL0: MOV AL,'0'

CALL OUTPUT

regs: CALL NEWLINE

MOV BX,OFFSET MESS2

MOV CX,3

CALL OUTMESS

MOV AH,0

MOV AL,RegA

CALL bin_out

CALL NEWLINE

MOV BX,OFFSET MESS3

MOV CX,3

CALL OUTMESS

MOV AH,0

MOV AL,RegB

CALL bin_out

CALL NEWLINE

MOV BX,OFFSET MESS4

MOV CX,3

CALL OUTMESS

MOV AH,0

MOV AL,RegD

CALL bin_out

CALL NEWLINE

POP DX

POP CX

POP BX

POP AX

RET

stmp ENDP

main PROC FAR

MOV AX,SELECTOR mydata

MOV ES,AX

rst: MOV RegA,1

MOV RegB,2

MOV RegD,3

L0: CALL ctrl

CALL indata

MOV AH,0

MOV AL,RegA

SHR AX,1

JNC next

ADD AL,1000B

next: MOV RegB,AL ;B:=ROR(A)

MOV AL,BUFF

MOV RegA,AL ;A:=X

MOV AH,0

SHR AX,1

JNC next1

ADD AL,1000B

next1:  MOV RegD,AL ;D:=ROR(X)

CALL stmp ;fase di stampa

CMP MJR,0

JZ L0

L1: CALL ctrl

MOV DL,RegD

MOV RegB,DL ;B:=D

MOV AL,RegA

MOV AH,0

SHR AX,1

JNC next2

ADD AL,1000B

next2:  MOV RegD,AL ;D:=ROR(A)

CALL stmp ;fase di stampa

CMP MJR,0

JZ L0

JMP L1

.EXIT

main ENDP

mycode ENDS

END main