[Back to SORTING SWAG index] [Back to Main SWAG index] [Original]

    {
    REYNIR STEFANSSON

    Some time ago I wangled myself into a beta testing team For a floppy
    disk catalogger called FlopiCat. This is a rather BASIC (in more than one
    way) Program, but works well enough.

    The built-in sorting routine was a bit quacked, so I wrote my own
    external sorter, which is both more versatile and faster (by far) than the
    internal one.

         Here it is, in Case someone can use the idea (and code):
    }

    Program FlopiSrt; { Sorts FlopiCat.Dat. }

    Const
      Maximum = 6000; { I don't need that many meself... }
      FName   : String[12] = 'Flopicat.Dat';

    Type
      fEntry = Record
        n : Array[1..4] of Char;
        i : Array[1..35] of Char;
        d : Array[1..39] of Char;
      end;

      En1 = Array[1..78] of Char;
      En2 = Record
        n : Array[1..4] of Char;
        f : Array[1..9] of Char;
        e : Array[1..3] of Char;
        z : Array[1..8] of Char;
        t : Array[1..15] of Char;
        d : Array[1..39] of Char;
      end;

      En3 = Record
        f, d : Array[1..39] of Char;
      end;

      pEntry = ^fEntry;

    Var
      Entry        : Array [1..Maximum] of pEntry;
      fc           : File of fEntry;
      Rev          : Boolean;
      LoMem        : Pointer;
      i,
      NumOfEntries : Integer;
      nfd          : Char;
      s            : String;

    Function ToSwap(i, j : Integer) : Boolean;
    Var
      Swop : Boolean;
    begin
      Swop := False;
      Case nfd OF
        { Sorting by disk number: }
        'N' : if Entry[i]^.n > Entry[j]^.n then
                Swop := True;
        { Sorting by File information: }
        'I' : if Entry[i]^.i > Entry[j]^.i then
                Swop := True;
        { Sorting by description: }
        'D' : if Entry[i]^.d > Entry[j]^.d then
                Swop := True;
        { Sorting by all the String: }
        'A' : if En1(Entry[i]^) > En1(Entry[j]^) then
                Swop := True;
        { Sorting by File name only: }
        'F' : if En2(Entry[i]^).f > En2(Entry[j]^).f then
                Swop := True;
        { Sorting by File extension only: }
        'E' : if En2(Entry[i]^).e > En2(Entry[j]^).e then
                Swop := True;
        { Sorting by File size: }
        'Z' : if En2(Entry[i]^).z > En2(Entry[j]^).z then
                Swop := True;
        { Sorting by date/time stamp: }
        'T' : if En2(Entry[i]^).t > En2(Entry[j]^).t then
                Swop := True;
        { Sorting by disk number/File info block: }
        'B' : if En3(Entry[i]^).f > En3(Entry[j]^).f then
                Swop := True;
      end;
      ToSwap := Swop xor Rev;
    end;

    { if I remember correctly, I settled on using shaker/shuttle sort. }
    Procedure SortIt;
    Var
      i, j,
      pb, pf,
      pp, pt : Integer;
      t      : pEntry;

      Procedure SwapIt(i, j : Integer);
      begin
        t := Entry[i];
        Entry[i] := Entry[j];
        Entry[j] := t;
      end;

    begin
      Write('0    entries processed.');
      i  := 0;
      pt := 2;
      pb := NumOfEntries;
      pf := 0;
      Repeat
        pp := pt;
        Repeat
          if ToSwap(pp - 1, pp) then
          begin
            SwapIt(pp - 1, pp);
            pf := pp;
          end;
          Inc(pp);
        Until pp > pb;

        pb := pf - 1;
        j  := i;
        i  := NumOfEntries - (pb - pt + 2);
        if (i MOD 10) < (j MOD 10) then
          Write(#13, i);
        if pb < pt then
          Exit;
        pp := pb;

        Repeat
          if ToSwap(pp - 1, pp) then
          begin
            SwapIt(pp - 1, pp);
            pf := pp;
          end;
          Dec(pp);
        Until pp < pt;

        pt := pf + 1;
        j  := i;
        i  := NumOfEntries - (pb - pt + 2);
        if (i MOD 10) < (j MOD 10) then
          Write(#13, i);
      Until pb < pt;
    end;

[Back to SORTING SWAG index] [Back to Main SWAG index] [Original]