ASM Community

Loop the chars into a buffer, terminate the string and display it.

Special Agent Oso: "Three special steps, that's all you need. Three special steps, and you'll succeed." :)

nope... you'll need to show a little effort here...

show your working code so far _then_ add a buffer to it and drop the char (which you have in al) in the buffer.

then we'll go step by step :)

.model small
.stack
.data
msg1 db "Input Name: $",13,10
fname db 50 dup(?)

.code

main proc

        mov ax, @data
        mov ds,ax

        mov dx, offset msg1
        mov ah,9
        int 21h

        loop1:
        mov bl,0dh
        mov cx,0
        mov ah,1
        int 21h
        cmp al,bl
        je done
        mov ,al
        loop loop1

        done:
        mov ax,@data
        mov ds,ax
        mov dx,offset fname
        mov ax,seg fname
        mov ds,ax

        mov ah,9
        int 21h

        mov ah,4ch
        mov al,0
        int 21h

main endp
end main

Here is whaat ive done.. and i got error..

You might want to mention what error you got, exzibi23. As JimmyClif mentions, you've got problems with the "loop" section. Nice reference to "asmloops"! They don't mention explicitly what happens if cx=0. Loop doesn't execute at all? Nope! Since the "loop" instruction decrements cx first, and then checks for zero, it'll execute the whole 64k times. By setting cx to zero - or any value - inside the loop, you've guaranteed an "infinite loop". But since you've got an exit from the loop, that should actually work okay, even if it isn't "right". Putting every character you get into the first byte in the "fname" buffer is a problem! You want to increment di!

At the beginning of your program, you do "mov ax, @data"/"mov ds, ax" to set ds to your data segment. Correct. Later, you reset ds again. This shouldn't hurt, but since "fname" is in your data segment, you shouldn't need to.

There's a neat instruction, "stosb". which will store al in and increment di all in one go, but there's a catch. "stosb" puts al in es:, not ds:. If, back at the beginning of your program when you had "@data" in ax, you did "mov es, ax" as well as the "mov ds, ax", you would be able to use this instruction. No great advantage to it - it's short (1 byte), and used to be fast in the olden days. Now, it's faster to do "mov , al"/"inc di"... probably even faster to do "add di, 1"... In 32-bit code, this segmented folderol is gone - I don't think anyone misses it! :)

If your error is simply that it's not printing anything, the "inc di" should fix it. If you're hanging forever in the input loop... you must not be checking the exit condition properly. Is "0Dh" correct for dos? In Linux, I'd look for "0Ah" when the victim... I mean "user" hits enter. I forget how dos does it, and I'm too lazy to check. :)

Really a pretty good job, for a "first draft". You'll have it working soon, I predict.

Best,
Frank

sorry for my mistakes.. im just a beginner in assembly.. thanks for those who answer.. :)

check out my code.. my question is, how can i print it?

.model small
.stack
.data
msg1 db "Input Name: $",13,10
fname db 50 dup(?)

.code

main proc

        mov ax, @data
        mov ds,ax

        mov dx, offset msg1
        mov ah,9
        int 21h

        mov di,offset fname

        loop1:
        mov bl,0dh
        mov ah,1
        int 21h
        cmp al,bl
        mov ,al
        inc di
        je done
        jmp loop1

        done:
        mov ax,@data
        mov ds,ax
        mov dx,offset fname
        mov ax,seg fname
        mov ds,ax

        mov ah,9
        int 21h


        mov ah,4ch
        mov al,0
        int 21h

main endp
end main


i remove the loop loop1..

i replace it with jmp loop1.. if the user hits enter, it will terminate.. :)

The names of the registers have meanings.

The ones with 'x' are the regular registers:
ax - Accumulator
bx - Base
cx - Counter
dx - Data

The 'i' stands for Index register:
si - Source index
di - Destination index

The 'p' stands for Pointer register:
bp - Base pointer
sp - Stack pointer

For various instructions, you cannot choose all the operands. For example, lodsw will always use the si register as the source address, and always load into ax. And stosw will always store ax to the destination address in di.
Therefore it is common to use di when storing data.

As for the mov di, 0, I think that's just a mistake. It has no meaning when di is overwritten with offset fname in the next line.

Yeah! Told you to write comments! :)

Go back to what JimmyClif told you in the first place:

"Loop the chars into a buffer, terminate the string and display it."

Which part have you left out?

Here's your latest(?) main loop...

You can call this label anything, but if you use a "meaningful name" it'll make your code easier to read. Say "what it's for"...

    get_next_char:
;        loop1:
        mov ah,01h ; "get character" subfunction of int 21h
        mov bh,0dh ; character to watch for to end input
        cmp bh,al  ; is user finished yet?

Now you've got a litttle problem. You havent "got" the character yet! You need to do the int 21h before you can compare the character to carriage-return... or store it. Incidentally, you don't have to put 0Dh in a register to do the comparison - "cmp al, 0Dh" would work...

        je done
        mov ,al ; store the character in our buffer
        inc di  ; advance to next location in the buffer

        int 21h  ; call dos - this wants to be done earlier!

;        jmp loop1
    jmp get_next_char ; see, it's all commented! :)

        done:

You might even want to call this "done_getting_input:", but "done:" is pretty clear. Now you need to terminate the string. Zero is a commonly used terminator, but int 21h/9 expects a $-terminated string (this is unusual - you won't see it in other OSen... or even elsewhere in dos!). I'm not sue I've got Tasm syntax right, but I think:

    mov byte ptr , '$' ; terminate the string

; print "my name is"
        mov dx,offset msg2
        mov ah,09h
        int 21h

; uh, was there something else you wanted to do here? :) :) :)

; exit the program
        mov ah,4ch
        mov al,0
        int 21h

Now at this point, the user can enter as much as he likes, and possibly overflow the buffer. Professionals do this. Every new version of (unnamed OS) that comes out has got new "exploits" in it. Often, buffer overruns. Amateurs should not do this!!!

If you were to go back to "loop" instead of "jmp", and load cx with a value *before* the top of you loop, that would prevent it. When you think about what value you want to have in cx before your loop, don't forget that we need one more byte for the '$'!!! Get it working first, if you want, but think about this! If you develop better habits than the "professionals" have got, the world will thank you! (except antivirus vendors) Sorry to be obsessive about this, but it really bugs me that they keep doin' it - year after year, decade after decade. It isn't as if this is a newly discovered problem!

Okay, okay, I'll calm down... To add a little to what Scali said about "why di?"... The rules for addressing in 16-bit code are quite restrictive: an (optional) offset, plus an (optional) index register (si, di), plus an (optional) base register (bx, bp). That's it! In 32-bit code, you can do stuff like   - you'll love it!

Further information about addressing: all x86 addresses involve a segment and an offset. In 32-bit code, the rules are different (we can usually ignore segment registers - whew!) - the segment register value (a "selector") is an index into an array of "descriptors". In 16-bit code, the value in the segment register is multiplied by 16 (shifted left by four) and added to the offset, to find the "linear address". (this is neccessary because a 16-bit register can only hold up to 65535, and that isn't enough memory for HLL programmers :)

The cs register is used to determine where our code can be found. Usually, ds is used to locate our data - but sometimes es. As you might expect, ss is used for the stack. This default behavior can be overwritten. For example, bp is a "base register", but unlike  bx, si, and di, it defaults to using ss. "mov , al" would be a legal way to store our character, but it would go in the stack segment instead of the data segment where we want it. "mov ds:" would work.

Anyway... ya gotta print your string before it'll print. :) This is what makes assembly... not "hard", but "tedious". You've got to tell the CPU every... single... thing! They're just not good at figuring out what we want.

Best,
Frank

Yeah... says that in the subject. :) Nasm, here.

Good job! (but you still allow a buffer overrun)

Now that you've figured out what's involved, take a look at int 21h/0Ah...

Best,
Frank

Whoa! Good catch baldr! I didn't notice that. Do you understand the difference, exzibi23? Important, so check it out!

Best,
Frank

exzibi23,

fname db 50 reserves only one byte. Next one belongs to msg2 if reordered, or to uninitialized memory that follows fname. In your case it belongs to 4-byte padding of data segment, then stack segment (TASM specific), so no harm is done, yet.