Why doesn't the following method recurse infinitely?

Question

The following method opensquare should cause infinite recursion as far as I can see and yet it doesn't cause lockups or error messages of any kind when I run it in my program. Also I can't figure out why showgrid[x+b][x+c] isn't set to true for certain values of b and c between -1 and 1 even on the initial call (opensquare called for 1st time).
Info about variables, arrays: x,y are always between zero and 9 and are passed to opensquare from a mousepressed method which converts the
pixel coordinates to minegrid, showgrid etc. coordinates between 0..9.
and showgrid[x][y] is always true before opensquare is called. For
recursive calls it looks to me like showgrid[x][y] will always be true.
showgrid, minegrid are 10 by 10 arrays of type boolean
number grid is a 10 by 10 array of type int
b & c are local ints to the method opensquare, specifically the for loops.
assuming that the if test condition is passed and none of the squares around x,y has numbergrid>0 I would think that the method would call itself infinitely because for b& c=0 from the two for loops would mean the method would call itself for the same element (x+0,y+0)=x,y the same element. Also it would jump to one element and then the method would execute for the element it just jumped from and go back and forth... and yet this method doesn't infinitely recurse. Also, it doesn't seem to call opensquare for some values of b&c even though it passes the test condition.
I really don't understand this. Could someone explain 1) why it doesn't infinitely recurse and 2) why for a (showgridl[x][y] element that doesn't for -1>b>1 -1>c>1, have any numbergrid[x+b][y+c] elements>0 around it and for -1>b>1 -1>c>1 no minegrid[x+b][y+c] elements that are true around it and meets the condition that [x+b]&[y+c] are both between 0 and 9) that it doesn't make showgrid[x+b][x+c] true for every x+b & y+c. In my program it doesn't make it true for every x+b,y+c assuming the previous conditions. It seems to head off in a direction of openingsquares in a x getting smaller y getting smaller direction and never seems to make showgrid[x+b[y+c] true for b>0&c=0.
here is the method:
public void opensquare(int x,int y){   
int count=0;
int squarecount=0;
if (minegrid[x][y])
{ done=true;}
while (!done) {
if (showgrid[x][y]) {
for (int b=-1; b<=1; b++)
for (int c=-1; c<=1; c++)
if ((x+b >= 0) && (x+b < XGRID) && (y+c >=0) && (y+c<YGRID) && (minegrid[x+b][y+c] == false ))
showgrid[x+b][y+c]=true;
if (numbergrid[x+b][y+c] > 0) {
done = true;
x=x+b; y=y+c;
opensquare(x, y);
else done=true;

Answer 1

done is a boolean global variable and is transparent to all methods. The mousepressed method sets done to false every time the left mouse button is pressed. Opensquare is called from the mousepressed method after done is set to false.
You say it's not recursion, it sure acts like recursion.
I get elements in showgrid being opened that are as far as 4 elements less in x and y then the element passed to opensquare. I get a max of about 14 elements of showgrid being set to true when they were all false before opensquare was called. Since the for loops only run through 9 elements of showgrid it must be calling opensquare again which then opens more elements, unfortunately it usually only runs in one direction with x and y getting smaller and to a lesser extent x getting bigger and y getting smaller. It almost never sets showgrid[x][y] elements to true with x and y getting bigger. It is recursion ( the method calling itself is what I understand as recursion). I don't understand why it doesn't recurse infinitely as I explained before with adjacent showgrid elements calling opensquare for each other infinitely, or even a showgrid element producing a call to opensquare for itself infinitely. If I take out the else done=true statement I get multiple errors displayed in the applet viewer window coming from opensquare (I can't see the error it goes by too fast). Seems to me if it fails the boundary test done will never be true for every single branch of opensquare called.