whats new ¦  programming tips ¦  indy articles ¦  intraweb articles ¦  informations ¦  links ¦  interviews
 misc ¦  tutorials ¦  Add&Win Game

Tips (1548)

Database (90)
Files (137)
Forms (107)
Graphic (116)
IDE (21)
Indy (5)
Internet / LAN (131)
IntraWeb (0)
Math (76)
Misc (127)
Multimedia (45)
Objects/
ActiveX (51)

OpenTools API (3)
Printing (35)
Strings (83)
System (268)
VCL (243)

Top15

Tips sort by
component


Search Tip

Add new Tip

Add&Win Game

Advertising

32 Visitors Online


 
...Stop memory leaks with the Masks.MatchesMask procedure?
Autor: Aaron Murgatroyd
Homepage: http://home.iprimus.com.au/amurgshere
[ Print tip ]  

Tip Rating (14):  
     


// The Masks unit has a bug when specifying
// masks that start with with a set, this bug
// even occurrs is a * is first and then a set.

// This is due to a small memory freeing issue
// If you step through the masks unit you
// will find it. Here is a replacement unit for
// the Masks unit which has the fixes in it.

{ *************************************************************************** }
{                                                                             }
{ Kylix and Delphi Cross-Platform Visual Component Library                    }
{                                                                             }
{ Copyright (c) 1995, 2001 Borland Software Corporation                       }
{                                                                             }
{ *************************************************************************** }


unit untMasks;

interface

uses 
SysUtils;

type
  
EMaskException = class(Exception);

  TMask = class
  private
    
FMask: Pointer;
    FSize: Integer;
  public
    constructor 
Create(const MaskValue: string);
    destructor Destroy; override;
    function Matches(const FileName: string): Boolean;
  end;

function MatchesMask(const FileName, Mask: string): Boolean;

implementation

uses 
RTLConsts;


const
  
MaxCards = 30;

type
  
PMaskSet    = ^TMaskSet;
  TMaskSet    = set of Char;
  TMaskStates = (msLiteral, msAny, msSet, msMBCSLiteral);
  TMaskState  = record
    
SkipTo: Boolean;
    case State: TMaskStates of
      
msLiteral: (Literal: Char);
      msAny: ();
      msSet: (Negate: Boolean;
        CharSet: PMaskSet);
      msMBCSLiteral: (LeadByte, TrailByte: Char);
  end;
  PMaskStateArray = ^TMaskStateArray;
  TMaskStateArray = array[0..128] of TMaskState;

function InitMaskStates(const Mask: string;
  var MaskStates: array of TMaskState; bDontAllocate: Boolean = False): Integer;
var
  
I: Integer;
  SkipTo: Boolean;
  Literal: Char;
  LeadByte, TrailByte: Char;
  P: PChar;
  Negate: Boolean;
  CharSet: TMaskSet;
  Cards: Integer;

  procedure InvalidMask;
  begin
    raise 
EMaskException.CreateResFmt(@SInvalidMask, [Mask,
      P - PChar(Mask) + 1]);
  end;

  procedure Reset;
  begin
    
SkipTo  := False;
    Negate  := False;
    CharSet := [];
  end;

  procedure WriteScan(MaskState: TMaskStates);
  begin
    if 
I <= High(MaskStates) then
    begin
      if 
SkipTo then
      begin
        
Inc(Cards);
        if Cards > MaxCards then InvalidMask;
      end;
      MaskStates[I].SkipTo := SkipTo;
      MaskStates[I].State  := MaskState;
      case MaskState of
        
msLiteral: MaskStates[I].Literal := UpCase(Literal);
        msSet:
          begin
            
MaskStates[I].Negate := Negate;
            if not bDontAllocate then
            begin
              
New(MaskStates[I].CharSet);
              MaskStates[I].CharSet^ := CharSet;
            end 
            else
              
MaskStates[I].CharSet := nil;
          end;
        msMBCSLiteral:
          begin
            
MaskStates[I].LeadByte  := LeadByte;
            MaskStates[I].TrailByte := TrailByte;
          end;
      end;
    end;
    Inc(I);
    Reset;
  end;

  procedure ScanSet;
  var
    
LastChar: Char;
    C: Char;
  begin
    
Inc(P);
    if P^ = '!' then
    begin
      
Negate := True;
      Inc(P);
    end;
    LastChar := #0;
    while not (P^ in [#0, ']']) do
    begin
      
// MBCS characters not supported in msSet!
      
if P^ in LeadBytes then
        
Inc(P)
      else
        case 
P^ of
          
'-':
            if LastChar = #0 then InvalidMask
            else
              begin
                
Inc(P);
                for C := LastChar to UpCase(P^) do Include(CharSet, C);
              end;
            else
              
LastChar := UpCase(P^);
              Include(CharSet, LastChar);
        end;
      Inc(P);
    end;
    if (P^ <> ']') or (CharSet = []) then InvalidMask;
    WriteScan(msSet);
  end;
begin
  
P     := PChar(Mask);
  I     := 0;
  Cards := 0;
  Reset;
  while P^ <> #0 do
  begin
    case 
P^ of
      
'*': SkipTo := True;
      '?': if not SkipTo then WriteScan(msAny);
      '[': ScanSet;
      else
        if 
P^ in LeadBytes then
        begin
          
LeadByte := P^;
          Inc(P);
          TrailByte := P^;
          WriteScan(msMBCSLiteral);
        end
        else
          begin
            
Literal := P^;
            WriteScan(msLiteral);
          end;
    end;
    Inc(P);
  end;
  Literal := #0;
  WriteScan(msLiteral);
  Result := I;
end;

function MatchesMaskStates(const FileName: string;
  const MaskStates: array of TMaskState): Boolean;
type
  
TStackRec = record
    
sP: PChar;
    sI: Integer;
  end;
var
  
T: Integer;
  S: array[0..MaxCards - 1] of TStackRec;
  I: Integer;
  P: PChar;

  procedure Push(P: PChar; I: Integer);
  begin
    with 
S[T] do
    begin
      
sP := P;
      sI := I;
    end;
    Inc(T);
  end;

  function Pop(var P: PChar; var I: Integer): Boolean;
  begin
    if 
T = 0 then
      
Result := False
    else
    begin
      
Dec(T);
      with S[T] do
      begin
        
P := sP;
        I := sI;
      end;
      Result := True;
    end;
  end;

  function Matches(P: PChar; Start: Integer): Boolean;
  var
    
I: Integer;
  begin
    
Result := False;
    for I := Start to High(MaskStates) do
      with 
MaskStates[I] do
      begin
        if 
SkipTo then
        begin
          case 
State of
            
msLiteral:
              while (P^ <> #0) and (UpperCase(P^) <> Literal) do Inc(P);
            msSet:
              while (P^ <> #0) and not (Negate xor (UpCase(P^) in CharSet^)) do Inc(P);
            msMBCSLiteral:
              while (P^ <> #0) do
              begin
                if 
(P^ <> LeadByte) then Inc(P, 2)
                else
                begin
                  
Inc(P);
                  if (P^ = TrailByte) then Break;
                  Inc(P);
                end;
              end;
          end;
          if P^ <> #0 then Push(@P[1], I);
        end;
        case State of
          
msLiteral: if UpperCase(P^) <> Literal then Exit;
          msSet: if not (Negate xor (UpCase(P^) in CharSet^)) then Exit;
          msMBCSLiteral:
            begin
              if 
P^ <> LeadByte then Exit;
              Inc(P);
              if P^ <> TrailByte then Exit;
            end;
        end;
        Inc(P);
      end;
    Result := True;
  end;
begin
  
Result := True;
  T      := 0;
  P      := PChar(FileName);
  I      := Low(MaskStates);
  repeat
    if 
Matches(P, I) then Exit;
  until not Pop(P, I);
  Result := False;
end;

procedure DoneMaskStates(var MaskStates: array of TMaskState);
var
  
I: Integer;
begin
  for 
I := Low(MaskStates) to High(MaskStates) do
    if 
MaskStates[I].State = msSet then Dispose(MaskStates[I].CharSet);
end;

{ TMask }

constructor TMask.Create(const MaskValue: string);
var
  
A: array[0..0] of TMaskState;
begin
  
FSize := InitMaskStates(MaskValue, A, True);
  FMask := AllocMem(FSize * SizeOf(TMaskState));
  InitMaskStates(MaskValue, Slice(PMaskStateArray(FMask)^, FSize));
end;

destructor TMask.Destroy;
begin
  if 
FMask <> nil then
  begin
    
DoneMaskStates(Slice(PMaskStateArray(FMask)^, FSize));
    FreeMem(FMask, FSize * SizeOf(TMaskState));
  end;
end;

function TMask.Matches(const FileName: string): Boolean;
begin
  
Result := MatchesMaskStates(FileName, Slice(PMaskStateArray(FMask)^, FSize));
end;

function MatchesMask(const FileName, Mask: string): Boolean;
var
  
CMask: TMask;
begin
  
CMask := TMask.Create(Mask);
  try
    
Result := CMask.Matches(FileName);
  finally
    
CMask.Free;
  end;
end;

end.


 

Rate this tip:

poor
very good


Copyright © by SwissDelphiCenter.ch
All trademarks are the sole property of their respective owners