line:
define X1 [ebp+24]
define Y1 [ebp+20]
define X2 [ebp+16]
define Y2 [ebp+12]
define COLOR [ebp+8]

define T [ebp-12]
define DELTAY [ebp-8]
define DELTAX [ebp-4]
macro ABS
{
cdq ; Om bit 31 är satt i EAX, så fylls EDX med 1 annars 0.

; Om EDX = 0xFFFFFFFF, dvs fylld av 1 då körs NOT på EAX, om 0 har EAX kvar sitt ursprungliga värde
xor eax,edx

;Den här är lurigare. om man gör en sub ax,0xffff översätter kompilatorn det som
;sub ax, byte -1. Varför den automatiskt tolkas som signed vet jag inte. men iaf
;det går att kringå med "word". Hursomhelst verkar det vara det som gäller för
;sub eax,edx. Dvs den räknas som ett signed tal av någon anledning.
;ska undersöka om karaktären ändras av att tillämpa "dword". Svar nej. Nåja det fungerar iaf.

sub eax,edx ;sub -1,, adderar ett --=+ om edx är = ffffffff såklart, vilket kräver ett negativt tal

}

push ebp
mov ebp,esp
sub esi,12 ; Make room for local variables 3*4 = 12

mov edi, [PHYS_BASE_PTR] ; Här varde Linear Frame Buffer

mov eax, Y1 ; y1->ebx
mov ebx, X1 ; x1->ebx

lea eax,[5*eax] ; eax *5^2
lea eax,[5*eax] ; i.e eax=1 becomes 25
shl eax,6 ; eax *=32. 1=800, 2 = 1600, 3 = 2400 and so on.. XRES=800
add edi,eax
shl ebx,1
add edi, ebx
mov ax, COLOR
mov [edi], ax ; sätter ut startpixeln

; Vissa saker utförs dubbelt. T e x kan man byta ut eax ovanför mot edx, och ebx vid * mot edx så slipper man hämta det från
; minnet vid *. subtraktionen under måste även korrigeras mot det. Ebx ovanför kan man ta bort från ** om man vill samt
; att man delar registret med 2 ovanför,, för att återställa ursprungsvärdet. Men för läsbarhetens skulle skiter jag i det.

; som x1,y1,x2,y2

;*****************************************GETS DELTAX*****************************************************************************;
mov eax, X2 ; x2->eax
mov ebx, X1 ; x1->ebx ;**
;mov eax,400
sub eax, ebx ; x2-x1
mov DELTAX, eax
;*********************************************************************************************************************************;

;*****************************************GETS DELTAY*****************************************************************************;
mov ecx, Y2 ; y2->ecx
mov ebx, Y1 ; y1->ebx ; *
;mov ecx,800
sub ecx, ebx
mov DELTAY, ecx
;*********************************************************************************************************************************;

;****************************************ABS (DELTAX) < ABS(DELTAY) ????**********************************************************;
ABS ; ABS(DELTAX); Clobber EDX
xchg eax,ecx ; ecx används som räknare i avsnittet under om den hamnar där.
ABS ; ABS(DELTAY); Clobber EDX

cmp ecx,eax ; if deltaX > Deltay
jle .DELTAY_HIGHER ; <= deltaY (slope >= 1) jump to DELTAY_HIGHER
;*********************************************************************************************************************************;

;**********************************ABS(DELTAX) > ABS(DELTAY)**********************************************************************;
fild dword DELTAY ; Lagrar ett heltal i mattecpus st0 o konverterar till flyttal
fidiv dword DELTAX ; st0 = deltay / deltax

mov eax,-1
mov edx,1
cmp dword DELTAX,0
cmovl edx,eax

mov DELTAX, edx
fimul dword DELTAX
fxch st1

mov [x],dword 0
add edx,edx ; 16 bitar,, varje steg måste vara 2,,

.draw:
add [x],edx

fadd st0,st1

fist dword T
mov eax,T

lea eax,[5*eax] ; eax *5^2
lea eax,[5*eax] ; i.e eax=1 becomes 25
shl eax,6 ; eax *=32. 1=800, 2 = 1600, 3 = 2400 and so on.. XRES=800

add eax, [x]
mov bx, COLOR
mov word [edi+eax],bx
loop .draw
mov esp,ebp
pop ebp
ret
;**********************************************************************************************************************************;

;***************************************ABS(DELTAY) > ABS(DELTAX)*****************************************************************;
.DELTAY_HIGHER:
mov eax,DELTAY ; We want the absolute DELTAY to be put into ECX. In DELTAX_HIGHER it will be so implicitly
ABS ; due to usage of a previously set ECXregister. A sacrifice of tiny speed for quite a lot
xchg ecx,eax ; of readability

fild dword DELTAX ; Lagrar ett heltal i mattecpus st0 o konverterar till flyttal
fidiv dword DELTAY ; st0 = deltax / deltay

mov eax,-1
mov edx,1
cmp dword DELTAY,0 ; do we want the line to go upwards or downward?
cmovl edx,eax ; cmovb dvs move if below fungerar inte, kan bero på att cmovL måste användas vid Signed tal
; Sub DeltaY med 0, förändras förstås ingen flagga. Sub är vad som implikeras av cmp.
; cmovl kontrollerar skiljaktigheten med overflow flag gentemot signflag,, och kan vara mer rätt.
; jmp $

mov DELTAY, edx
fimul dword DELTAY
fxch st1

mov [y], edx
mov [y],dword 0
.drawy:
add[y], edx ; this increases Y with -1 or +1, We use EBX to increase because we dont want edx to add withitself

fadd st0,st1 ; add X with DeltaX / DeltaY, it could be 0,5 and get rounder to 1, it could be 0,3 and downroundet to 0
; who knows who knows!
fist dword T
mov eax,T
shl eax,1

mov ebx,[y]
lea ebx,[5*ebx] ; edx *5^2
lea ebx,[5*ebx] ; i.e edx=1 becomes 25
shl ebx,6 ; edx *=32. 1=800, 2 = 1600, 3 = 2400 and so on.. XRES=800

add eax,ebx
mov bx,COLOR
mov word [edi+eax],bx

loop .drawy

mov ebp,esp
pop ebp
ret 20 ;la till det nyligen,, måste testas,
;**********************************************************************************************************************************;
x: rd 1 ;dom här får vara statiska tills vidare.
y: rd 1