;;

;; hello.asm

;; Basics in Assembler

;;

global start

%define SYS_INTERRUPT 0x80

  msg db "ASM Tutorial for 32 Bit Intel!", 10, 0

  len equ $-msg

  buffer: times 100 db '.'

  quotient: dd 10

start:

  call _entryPoint

  mov eax, 1000

  mov ebx, -1024

  call calculate

  mov eax, 1000

  mov ebx, 1024

  call calculate

  call asm_exit

  ret

asm_exit:

  push DWORD 0

  mov eax, SYSCALL_EXIT

  int SYS_INTERRUPT

  ret

asm_write:

  mov eax, SYSCALL_WRITE

  int SYS_INTERRUPT

  ret

;;

;;  CL: NEGATIVE BIT - BOOLEAN

;; EAX: NUMBER TO CONVERT

;; EBX: counter

;;

integerToString:

  xor cl, cl

  mov ebx, 0

  lea si, [buffer]

  mov di, si

  cmp eax, 0

  jg loop

  ;; SET NEGATIVE

  mov cl, 1

  ;; reverse internal negative representation

  not eax

  inc eax

  loop:

    xor edx, edx

    idiv DWORD [quotient]

    add edx, 30h

    mov [si], edx

    inc si

    inc ebx

    cmp eax, 0

    jne loop

  ;; Save current string position

  push si

  ;; ADD +/- SIGN

  cmp cl, 0

  jz positive

  jg negative

  positive:

    mov BYTE [si], '+'

    jmp reverse

  negative:

    mov BYTE [si], '-'

    jmp reverse

  ;; Reverse the number in human readable format

  reverse:

	;; swap first with last and so on

    mov al, BYTE [si]

    mov ah, BYTE [di]

    mov BYTE [si], ah

    mov BYTE [di], al

    dec si

    inc di

    ;; 1 2 3 4 5 6

    ;; 6         1

    ;;   5     2

    ;;     4 3

    ;;

    cmp si, di

    jg reverse

  ;; Restore current String position

  pop di

  ;; add newline and string terminator

  newline:

    mov BYTE [di], 10

    inc di

    mov BYTE [di], 0

    inc di

    ;; add the two chars to the counter

    add ebx, 2

  ret

calculate:

  imul ebx

  call integerToString

  push DWORD ebx

  push DWORD buffer

  push DWORD 1

  call asm_write

  add esp, 12

  ret

  push DWORD len      ;; Text Len

  push DWORD msg      ;; Pointer to String

  push DWORD 1        ;; stdout

  call asm_write      ;;

  add esp, 12         ;; cleanup stack

  ret