list trouble - Gpc

19 Jun 2002


      Hi, all
I'm having trouble with list management again.
The code snipper below is part of a much longer program.  It crashes 
apparently at random, sometimes after looping several thousand times.  A 
simplified version ran "forever", so I know the basic strategy is fine.  The 
crash occurs upon "dispose"ing a record in list Root, and gives sometimes a 
Page Fault, sometimes a General Protection Fault.  Examining the record being 
disposed shows no pattern, such as being at the end of the list, near the edge 
of the lattice, etc.
The object of the procedure is to define pathways through the 3-D maze defined 
in array Latt.  Latt codes for connections in the positive and negative x, y, 
and z directions, and whether a given point has been tested yet (via Occ).  In 
each pass through the list Root, the record location is examined for connected 
neighbors.  The record is then disposed, and connected neighbors are inserted 
into the list "LNext".  Then LNext is given to Root for the next pass.  All 
insertions and deletions are therefore at the first position in a list.
It's probably an obvious problem, and I'm hoping fresh eyes can see it.
thanks,
Toby
---------------------------------
Procedure Advance(var Root      : PRec;  {rx, ry, rz: medcard; next: PRec}
                    var Latt      : PPLary; (3D lattice in schema format}
                    var here,
                        count     : medCard);
  {Local to NumLatt.
  1.  Identify adjacent, accessible sites.
  2.  if sites are unoccupied, insert them into LNext.
  3.  Delete Self from Root.
  4.  Set Root = Lnext.}
  var
    LNext,
    PSelf     : PRec;
    lx, ly, lz,                                  {neighboring locations}
    dir       : medCard;                         {directions}
    Conduct   : boolean;                         {=accessible site}
begin
    LNext := Nil;
    while (Root <> Nil) do begin
      PSelf := Root;
      with PSelf^ do for dir := 1 to 6 do begin {check all 6 directions}
        lX := rX;
        lY := rY;
        lZ := rZ;
        case dir of
      1 : if (rX > 1) then begin               {-X direction}
            lX := rX-1;
            Conduct := ((Latt^[rX]^[rY,rZ] AND Xn) = Xn);
          end else Conduct := False;
      2 : begin                                {-Y direction}
            if (rY = 1) then lY := ny else lY := rY-1;
            Conduct := ((Latt^[rX]^[rY,rZ] AND Yn) = Yn);
          end;
      3 : begin                                {-Z direction}
            if (rZ = 1) then lZ := nz else lZ := rZ-1;
            Conduct := ((Latt^[rX]^[rY,rZ] AND Zn) = Zn);
          end;
      4 : begin                                {+Z direction}
            if (rZ = nz) then lZ := 1 else lZ := rZ+1;
            Conduct := ((Latt^[rX]^[rY,rZ] AND Zp) = Zp);
          end;
      5 : begin                                {+Y direction}
            if (rY = ny) then lY := 1 else lY := rY+1;
            Conduct := ((Latt^[rX]^[rY,rZ] AND Yp) = Yp);
          end;
      6 : if (rX >= nx) then Conduct := False else begin{+X direction}
            lX := rX+1;
            Conduct := ((Latt^[rX]^[rY,rZ] AND Xp) = Xp);
          end;
        end;                                     {case}
if (Conduct and (Latt^[lX]^[lY,lZ] < Occ)) then begin {unoccupied site}
          inc(count);                            {count newly accessible}
          LInsert(LNext, lX, lY, lZ);            {insert into LNext}
          Latt^[lX]^[lY,lZ] := Latt^[lX]^[lY,lZ] OR Occ;{mark as occupied}
          if ((not Infinite) and (lX = nx)  {check for breakthrough}
          and ((Latt^[lX]^[lY,lZ] AND Xp) = Xp))
          then begin
            Infinite := True;
            MinPath := here;
          end;
        end;                                     {if Conduct}
      end;                                       {for dir}  
      Root := Root^.next;                        {advance through list}
write('a');
      dispose(PSelf);            { <<=== program crashes here }
write('b. ');
    end;
    Root := LNext;
  end;                                           {Advance}