The Programming Challenge Master Thread - Page 21

section      .text:
    global _start                       ; must be declared for linker (ld)

_start:                                 ; linker entry point

        pop     eax     ; get number of parameters into eax
        pop     ebx
        pop     ebx     ; get second parameter into ebx

        call    parseArguments ; eax = N = max number of asterisks
        mov     edi, eax       ; save to edi as well for future references

        shl     eax, 1
        dec     eax ; eax = total number of lines to print = 2*N - 1

        xor     ebx, ebx; ebx = lines counter  = 0


write_next_line:        
        cmp     ebx, eax
        jge     exit ; when ebx(line counter) >= eax(total num lines to write) that means we are finished

        ; determine number of asterisks to print on this line
        mov     esi, ebx
        inc     esi
        cmp     esi, edi
        jle     print_asterisks
        sub     esi, edi
        neg     esi
        add     esi, edi
        

print_asterisks:

        ; now esi contains number of asterisks to print on this line
        
print_next_asterisk:
        mov     edx, 1 ; write only one character
        mov     ecx, ASTERISK ; text to write
        call    print

        dec     esi ; esi -= 1
        jne     print_next_asterisk ; if esi != 0 goto print_one_asterisk

print_NEW_LINE:
        mov     edx, 1 ; write only one character
        mov     ecx, NEW_LINE ; text to write
        call    print

        inc     ebx ; increment lines counter
        jmp     write_next_line

exit:
        mov     eax,1   ; system call number (sys_exit)
        int     0x80    ; call kernel


; printing routine, epxect string and length to print in ecx, edx
print:
        push    ebx
        push    eax
        mov     ebx,1   ; file descriptor (stdout)
        mov     eax,4   ; system call number (sys_write)
        int     0x80    ; call kernel
        pop     eax;
        pop     ebx
        ret    


; routine that checks input arguments count and stores program's argument into eax 
; (as properly parsed number)
; expects number of arguments in eax, pointer to first program argument string in ebx
; any argument error is reported to screen and program ends, if no argument is provided 
; then short usage information is displayed and program eds
parseArguments:
                
        cmp eax, 2
        jne parseError

        call parseNumber

        ret

parseError:
        
        ; print usage
        mov edx, USAGE_LEN
        mov ecx, USAGE
        call print
        
        ; exit
        mov eax, 1
        int 0x80


; routine that checks if string in ebx pointer contains only characters '0'..'9' 
; and the number is < MAX_ALLOWED_SIZE  
; and returns the integer it represents in eax (or ends with displaying error)
parseNumber:
        xor     ecx, ecx ; counter of read characters, initialized to 0
        xor     edx, edx ; intermediate value of the number processed so far, initialized to 0

parse_next_char:
        cmp     edx, MAX_ALLOWED_SIZE
        jg      checkNumberError ; out of range error

        movzx   eax, byte [ebx + ecx] ; store next byt of the string into eax
        cmp     eax, 0
        je      parseNumberEnd ; ending byte == 0 has been reached -> goto end

        ; edx = edx * 10
        mov     esi,edx
        shl     esi,3
        mov     edi, edx
        shl     edi,1
        mov     edx, esi
        add     edx, edi

        ; check character is between '0'..'9'
        cmp     eax, '0'
        jl      checkNumberError
        cmp     eax, '9'
        jg      checkNumberError

        ; everything OK, so we can add the next digit to our intermediate value
        sub     eax, '0'
        add     edx, eax

        inc     ecx
        jmp     parse_next_char
        
checkNumberError:
        ; print error message
        mov     edx, BAD_FORMAT_LEN
        mov     ecx, BAD_FORMAT
        call    print

        ; exit
        mov     eax, 1
        int     0x80

parseNumberEnd: 
        
        ; make sure that at least one character was read 
        ; (under normal circumstances this should be always true)
        cmp     ecx, 0
        je      checkNumberError

        ; intermediate value in edx is now result, store it into eax and return
        mov     eax, edx
        ret     


section .data
ASTERISK        db      '*'
NEW_LINE        db      0x0A
MAX_ALLOWED_SIZE equ    200
BAD_FORMAT      db      'Bad format or out of range',0x0A
BAD_FORMAT_LEN  equ     $ - BAD_FORMAT
USAGE           db      'Usage: asterisks NUM_ASTERISKS',0x0A
USAGE_LEN       equ     $ - USAGE