Well, do you know what a pxl-test returns outside of the screen? Do I have to do exception handeling right there?

That's clever for this use.

Again, thanks, but I came up with another, also very fast (maybe faster than yours ) routine for fixed memory flood filling by myself.
It used besides the drawing buffer(s) a stack (L1) and a 768 byte second buffer.
You can imagine that it works like memory swapping on a computer, if the RAM is full, data will be stored on the hard drive instead.
My routine searches iterative for pixels to fill using the stack, but if the stack overflows, it swaps to the other buffer using the slower searching routine.
When the stack empties, the data will be put back on the stack.
Like this I can achieve small areas filled extremely fast and bigger areas also with decent speed.
The only disadvantage is that it uses another 768 byte buffer (L3 when not uing grayscale) and L1 as stack. But I'm able to carry that.

:.FLOOD
:Buff(768)→GDB1
:15→A .Coordinates of "paint bucket"
:15→B
:0→S→D→C .Screen buffer size, data buffer size and counting var
:PUS(A,B) .Add the first pixel to stack
:While S+D . as long there's sth in the buffers
:C++
:POP() .Get a pixel
:!If pxl-Test(P,Q) .Test if it's off
:Pxl-On(P,Q) .if yes, turn it on
:P?PUS(P-1,Q) .Put pixels around it on the stack
:P-95?PUS(P+1,Q)
:Q-63?PUS(P,Q+1)
:Q?PUS(P,Q-1)
:End
:C^64??DispGraph .Only display every 64 time; not needed
:ReturnIf getKey(15)
:End
:DispGraph
:Return
:
:Lbl PUS .Push algorithm
:ReturnIf pxl-Test(r1,r2) .only push if the pixel is white
:If D-357 .if stack isn't full yet
:r1→{D*2+L1} .add to stack
:r2→{D*2+1+L1}
:D++ .increment stack pointer
:sub(CHKr,r1,r2) .check if pixel is black on the back buffer, if yes, remove it there
:Else!If pxl-Test(r1,r2,GDB1) .if stack is full, make sure that the pixel isn't in memory yet
:Pxl-On(r1,r2,GDB1) .turn it on on the back buffer
:S++ .increment buffer size
:End
:Return
:
:Lbl POP .Pop algorithm
:If D .if there's something on the stack
:D-- .decremt stack pointer
:{D*2+L1}→P .get the coordinates from the stack
:{D*2+1+L1}→Q
:CHK(P,Q) .check if pixel is black on the back buffer, if yes, remove it there
:Else .if stack empty
:For(Q,0,63 .go on searching the back buffer (slow...)
:For(P,0,95
:If pxl-Test(P,Q,GDB1) .if you got a pixel
:Pxl-Off(P,Q,GDB1) .turn it off
:S-- .decrement the buffer size
:Return .return to main
:End
:End
:End
:End
:Return
:
:Lbl CHK .check algorithm
:If pxl-Test(r1,r2,GDB1) .check if pixel is black on the back buffer
:Pxl-Off(r1,r2,GDB1  .if yes, remove it there
:S-- .decrement the buffer size
:End
:Return


What about using an arbitrary buffer in the program file? I'm gonna have grayscale too, but I think I can afford having that buffer.

That's actually an interesting thought... 
Maybe I'll add that later... firstly, my next step is to get the main program working, and then we'll see.