Problem with rendering text in text editor.

Hi,
Not really if this belongs to the "Main" forum or the "OS Construction Forum",
but this question belongs to the "My OS" category so I guess it's better to post it here.
I am in the process of writing a text editor for my 32-bit OS, I am taking some ideas from the MikeOS text editor, with some changes, got a really weird problem with the editor explained later in this post.
Basically the editor works like this:
-It has an internal variable called skip lines, which keeps a track of how much lines to skip (as I can't render the whole text file on a 90x60 screen).
-The render text function sees the number of lines to skip, and keeps ignoring the text, until ECX is 0, (note: ECX register is set to the number of lines to skip). It then calls display_loop which displays the actual text.
-The display_loop function will keep out putting the text until the end of screen (Screen Y = 58 ) has been reached or EOF and grabs input.
-There are some variable reference in the code
last_byte_addr - Last byte of the file (Load Address + File Size)
skip_lines - Lines to skip
cursor_byte - Pointer to the current user location in the file
cur_X - Cursor Location (X)
cur_Y - Cursor Location (Y)
Now the code Smile

Code:

render_text:
        ;; print text editor message blah, blah
        call setup_screen
        ;; display text from 0, 3
        mov dh, 3 ; X
        mov dl, 0 ; Y
        call os_move_cursor
        ;; ESI should point to start of file
        mov esi, LOAD_BUFFER                    
        ;; lines to skip
        mov dword ecx, [skip_lines]             
redraw:
        ;; 0 lines to skip??
        cmp ecx, 0                      
        ;; cool. display the text then
        je display_loop          
        ;; okay maybe not, decrement one line to skip
        dec ecx                                 
.skip_loop:
        ;; grab a char from ESI, increment esi, and put the char in AL
        lodsb                   
        ;; newline char?
        cmp al, NEWLINE
        ;; keep skipping characters if not
        jne .skip_loop                          
        ;; if we found a newline char jump back to redraw and check if 
        ;; we have any lines pending
        jmp redraw
display_loop:
        ;; ESI now points to the start of text to display
        lodsb                   
        ;; newline char?
        cmp al, NEWLINE
        jne skip_return
        ;; grab the cursor position
        call os_get_cursor_pos
        ;; set X to 0
        mov dl, 0       
        call os_move_cursor
skip_return:
        ;; get the cursor position
        call os_get_cursor_pos          
        ;; reached the maximum X position? (90)
        cmp dl, MAX_X
        je .no_print
        ;; print the character if not so
        call os_print_char
.no_print:
        mov dword ebx, [last_byte_addr]
        ;; EOF?
        cmp esi, ebx            
        ;; skip and get input
        je near get_input
        ;; Last Y co-ordinate?
        call os_get_cursor_pos          
        cmp dh, MAX_Y - 2
        ;; get input if so
        je get_input                    
        ;; or get back to display loop
        jmp display_loop
.....................
;; set user cursor position, validate input etc.
.....................
;; here's the go_down routine
go_down:
        pushad
        ;; ECX should point to pointer of the current point in the file (????????)
        mov dword ecx, [cursor_byte]
        ;; ESI should point to the place we loaded the file
        mov esi, LOAD_BUFFER
        ;; And now ESI points to the location of the current pointer of the...?????
        add esi, ecx                            
.loop:
        ;; check if the user is trying to scroll down after he/she has reached
        ;; EOF
        inc esi
        cmp dword esi, [last_byte_addr]
        ;; do nothing if so.
        je .do_nothing          
        ;; cool, get the real pointer back
        dec esi
        ;; into AL
        lodsb           
        ;; increment pointer
        inc ecx                         
        ;; newline??
        cmp al, NEWLINE
        ;; loop then
        jne .loop       
        ;; cool. set the pointer ..of... .. to ECX
        mov dword [cursor_byte], ecx
        ;; nowhere to go???
.nowhere_to_go:
        ;; pop all regs
        popad
        ;; EODB (End of Display Buffer)???
        cmp byte [cur_Y], MAX_Y - 3             
        ;; scroll the entire file down 
        je .scroll_file_down
        ;; else increment the cur_Y
        inc byte [cur_Y]                        
        ;; set cur_X to 0
        mov byte [cur_X], 0
        ;; and render text again
        jmp render_text
.scroll_file_down:
        ;; cool one more line to skip 
        inc dword [skip_lines]                  
        ;; set cur_X to 0
        mov byte [cur_X], 0
        ;; render text
        jmp render_text                         
.do_nothing:
        ;; else just exit :S
        popad
        jmp render_text

Now the screen output (this happens at exactly the same position for every
text file)

And to make matters worse this is the output after scrolling down the text file.

So yeah, the problem IMO is in the render_text function, but I am tired of finding out where???
Cheers,
sid