Witam.Mam pewien problem.Chce napisac program, ktory bedzie pobieral znak z klawiatury i nastepnie go wyswietlal w ukladzie znakowym.Liczba ukladow znakowych rowniez ma byc wybierana z klawiatury.Czyli np. wybieram 2 i znak # to program wyswietli:
##########

##########
##########

##########
Mam juz napisany programik, ale znak jak i liczba ukladow znakowych przypisana jest "na sztywno" w programie.Jak zrobic to pobieranie z klawiatury?
Oto program, ktory dotad napisalem:

title Program Programik

.model small
.stack 100h

.data
jeden db "", 0dh, 0ah, '$' ;
dwa db " ", 0dh, 0ah, '$' ; rodzaj znaku wyswietlanego
trzy db "", 0dh, 0ah, '$' ;

.code
main proc
mov ah,10h
int 16h

mov ax,@data
mov ds,ax

mov cx,2 ;ilosc ukladow znakowych
petla:
call pierwsza
call druga
call trzecia
loop petla

mov ax,4C00h
int 21h
main endp

pierwsza proc
mov ah,9
mov dx,offset jeden
int 21h
ret
pierwsza endp

druga proc
mov ah,9
mov dx,offset dwa
int 21h
ret
druga endp

trzecia proc
mov ah,9
mov dx,offset trzy
int 21h
ret
trzecia endp

end main

Dzieki za podpowiedzi.:)Pozdrawiam

Ps. w drugiej i piatej linii na rysunku, ktory pokazalem powinno byc # potem 8 spacji i znowu #

.model small
.stack 100h

.data
 tekst1  db "Podaj znaku: $"
 tekst2  db 0dh, 0ah, "Podaj ile powt: $"

 szablon db 0dh, 0ah
         db "**********", 0dh, 0ah 
         db "*        *", 0dh, 0ah 
         db "**********", '$'

 liczba  dw 0
 pom     db 5 dup(?)
 podst   DW 10
.code
main proc
 mov ax,@data
 mov ds,ax

 lea dx, tekst1
 call pisz
 xor ax, ax
 int 16h    
 lea di, szablon
 call zamien
 call znak


 lea dx, tekst2
 call pisz
 lea  di, pom
 call readln
 lea  si, pom
 call val


 mov cx,ax        ; ilosc ukladow znakowych
 or cx, cx
 jz @zero_razy
 petla:
  lea dx, szablon
  call pisz
 loop petla
 @zero_razy:
 mov ax,4C00h
 int 21h
main endp

; WE : ds:dx <- bufor tekstu do wyswietlenia 
pisz proc
 mov ah, 9
 int 21h
 ret
pisz endp

; WE  : ds:di <- szablon do zamiany
;       al    <- kod ASCII
; info: Podmienia wszystkie gwiazdki w buforze na kod w AL, aż do napotkania znaku końca "$"
zamien proc
 @zamiana:
  mov ah, ds:[di]
  cmp ah, "$"
  je @koniec_
  cmp ah, "*"
  jne .dalej
   mov ds:[di], al
  .dalej:
  inc di
 jmp @zamiana 
 @koniec_:
 ret
zamien endp

; WE : ds:di - bufor 5 znakow
; WY : cx    - dlugosc pobranego ciagu => max 5
;      ds:di - pobrany ciag znakow
readln proc
 xor cx, cx
 .pet:  
  xor ax, ax
  int 16h 
  cmp al, '0'
  jb @nie_cyfra
  cmp al, '9'
  ja @nie_cyfra
  cmp cx, 5
  je @nie_cyfra
   mov ds:[di], al
   inc di
   inc cx  
   call znak
  @nie_cyfra: 
  cmp al, 8
  jne @nie_backspace
  cmp cx, 0
  je @nie_backspace
   dec cx
   dec di
   push cx  
   call back
   mov al, ' '
   call znak
   call back
   pop cx
  @nie_backspace:
  cmp al, 13
  jne .pet
 ret
 back:
  mov ah, 03h  
  xor bh, bh
  int 10h
  dec dl
  mov ah, 02h  
  int 10h
 ret
readln endp

; WE: al <- znak do wyswietlenia
znak proc
 mov ah, 0eh
 xor bh, bh
 int 10h
 ret
znak endp

; WE : ds:si <- liczba w formie tekstu ASCII
;      cx    <- liczba cyfr(dlugosc tekstu)
; WY : ax    <- wartosc liczby;
val proc
 xor dx, dx
 xor ax, ax
 or cx, cx
 jz @papa
 @pet:
  mul word ptr podst
  mov bl, ds:[si]
  sub bl, '0'
  add al, bl
  adc ah, 0
  inc si
 loop @pet  
 @papa:
 ret
val endp
end main

Ps. Stosuj tagi ;-p

Dzieki wielkie.Juz sprawdzam dzialanie :) Jupi...