views:

463

answers:

2

Hello. Im first time here.I am a college student. I've created a simple program by using assembly language. And im wondering if i can use loop method to run it almost samething as what it does below the program i posted. and im also eager to find someome who i can talk through MSN messanger so i can ask you questions right away.(if possible) ok thank you


.MODEL small
.STACK 400h

.data


prompt                 db      10,13,'Please enter a 3 digit number, example 100:',10,13,'$'    ;10,13 cause to go to next line
first_digit         db      0d
second_digit            db      0d
third_digit         db      0d
Not_prime               db      10,13,'This number is not prime!',10,13,'$'
prime                   db      10,13,'This number is prime!',10,13,'$'
question                db      10,13,'Do you want to contine Y/N $'
counter                 dw      0d
number                  dw      0d
half                    dw      ?


.code


Start:


      mov ax, @data         ;establish access to the data segment
      mov ds, ax            
      mov number, 0d        

LetsRoll:


        mov dx, offset prompt          ; print the string (please enter a 3 digit...)
        mov ah, 9h                      
        int 21h                         ;execute
                                        ;read FIRST DIGIT
    mov ah, 1d          ;bios code for read a keystroke
    int 21h             ;call bios, it is understood that the ascii code will be returned in al
    mov first_digit, al     ;may as well save a copy
    sub al, 30h         ;Convert code to an actual integer
    cbw             ;CONVERT BYTE TO WORD. This takes whatever number is in al and
                    ;extends it to ax, doubling its size from 8 bits to 16 bits
                    ;The first digit now occupies all of ax as an integer
    mov cx, 100d            ;This is so we can calculate 100*1st digit +10*2nd digit + 3rd digit
    mul cx              ;start to accumulate the 3 digit number in the variable imul cx
                    ;it is understood that the other operand is ax
                    ;AND that the result will use both dx::ax
                    ;but we understand that dx will contain only leading zeros
    add number, ax          ;save
                    ;variable <number> now contains 1st digit * 10
                    ;----------------------------------------------------------------------

                    ;read SECOND DIGIT, multiply by 10 and add in
    mov ah, 1d          ;bios code for read a keystroke
    int 21h             ;call bios, it is understood that the ascii code will be returned in al
    mov second_digit, al        ;may as well save a copy
    sub al, 30h         ;Convert code to an actual integer
    cbw             ;CONVERT BYTE TO WORD. This takes whatever number is in al and
                    ;extends it to ax, boubling its size from 8 bits to 16 bits
                    ;The first digit now occupies all of ax as an integer
    mov cx, 10d         ;continue to accumulate the 3 digit number in the variable
    mul cx              ;it is understood that the other operand is ax, containing first digit
                    ;AND that the result will use both dx::ax
                    ;but we understand that dx will contain only leading zeros. Ignore them
    add number, ax          ;save -- nearly finished
                    ;variable <number> now contains 1st digit * 100 + second digit * 10
                    ;----------------------------------------------------------------------

                    ;read THIRD DIGIT, add it in (no multiplication this time)
    mov ah, 1d          ;bios code for read a keystroke
    int 21h             ;call bios, it is understood that the ascii code will be returned in al
    mov third_digit, al     ;may as well save a copy
    sub al, 30h         ;Convert code to an actual integer
    cbw             ;CONVERT BYTE TO WORD. This takes whatever number is in al and
                    ;extends it to ax, boubling its size from 8 bits to 16 bits
                    ;The first digit now occupies all of ax as an integer
    add number, ax          ;Both my variable number and ax are 16 bits, so equal size
        mov ax, number          ;copy contents of number to ax
        mov cx, 2h          
        div cx              ;Divide by cx
        mov half, ax            ;copy the contents of ax to half
        mov cx, 2h;         
        mov ax, number;         ;copy numbers to ax
        xor dx, dx          ;flush dx
    jmp prime_check         ;jump to prime check

print_question:


        mov dx, offset question     ;print string (do you want to continue Y/N?)
        mov ah, 9h          
        int 21h             ;execute
        mov ah, 1h          
        int 21h             ;execute
        cmp al, 4eh         ;compare 
        je Exit             ;jump to exit
        cmp al, 6eh         ;compare
        je Exit             ;jump to exit 
        cmp al, 59h         ;compare
        je Start            ;jump to start
        cmp al, 79h         ;compare
        je  Start           ;jump to start

prime_check:


        div cx;             ;Divide by cx
        cmp dx, 0h          ;reset the value of dx
        je  print_not_prime     ;jump to not prime 
        xor dx, dx;         ;flush dx
        mov ax, number          ;copy the contents of number to ax
        cmp cx, half            ;compare half with cx
        je print_prime          ;jump to print prime section
        inc cx;             ;increment cx by one
        jmp prime_check         ;repeat the prime check 

print_prime:


        mov dx, offset prime        ;print string (this number is prime!)
        mov ah, 9h          
        int 21h             ;execute
        jmp print_question      ;jumps to question (do you want to continue Y/N?) this is for repeat

print_not_prime:


        mov dx, offset Not_prime    ;print string (this number is not prime!)
        mov ah, 9h          
        int 21h             ;execute
        jmp print_question      ;jumps to question (do you want to continue Y/N?) this is for repeat

Exit:


    mov ah, 4ch             
    int 21h             ;execute exit           

        END Start
+1  A: 

...You mean use a loop? You already are. Twice.

Or do you mean use the LOOP instruction? If that's your goal, i'd say don't bother. Last i heard, these days, LOOP is slower on most processors than the equivalent dec, compare, and branch. Add to that the fact that in your case, 1 and 0 are special (dividing by 1 will always work, throwing off your logic, and by 0 it'll cause an error), and it makes it not worth your while to LOOP.

cHao
From my experience with similar cases, I'm inclined to think that this program is just copied from somewhere, and chris doesn't actually understand what's in there and what it does and how. :-))
Fyodor Soikin
i donno why there is such a offended reply. I thought this website to for helpe each other. please gtfo if you don't feel like help here.
chris
@chris - welcome to StackOverflow and good luck with the assembly. To Fyodor's point, there's a fine line between helping and doing someone else's (home)work. Your question is pretty much on the line, so don't be offended if people expect you to do your own studying and ask precise, careful questions. Best of luck!
Sam Post
A: 

Im no assembly expert but I think the ways you loop in assembly is either finit (iterate): define a max number of loops and increment a value to compare with for each time finish it with a je.

The conditional loop would be the same thing but instead of incrementing a number you compare your pre-defined value to another value and end with a je so it will loop until you achieved what you want.

I did not take a close look at your code though as im kind of in a hurry, so sorry if this wasnt what you ment.

Edit: of course you dont have to use the jump if equal instruction, you could also go with not equal or any of the other ones depending on the situation.

Edit 2: heh forgot about the most basic one, just jump back to the start of the loop for an infinite loop. Though you'd probably want something to break it with so its not very common :)

Jonas B
Incrementing and using a *je* involves an extra instruction - the *cmp*. You are better off decrementing your counter register and doing a *jnz* or variant (jump on not zero - the Zero (Z) flag gets set when a register hits zero).
slugster
ok thanks for the quick reply. i think ill stick with this then. thx
chris
What he said - As I said I'm no assembly expert, didn't even think about that :)
Jonas B
One extra instruction in the grand scheme of things it doesn't really matter. Many people doing asm tend to be purists, oneof the reasons why they do asm is that they want things to be as tight and optimized as possible. So i just thought i would point that out :)
slugster