cxregexpr.pas

来自「胜天进销存源码,国产优秀的进销存」· PAS 代码 · 共 2,586 行 · 第 1/5 页

{********************************************************************}
{                                                                    }
{       Developer Express Visual Component Library                   }
{       ExpressEditors                                               }
{                                                                    }
{       Copyright (c) 1998-2008 Developer Express Inc.               }
{       ALL RIGHTS RESERVED                                          }
{                                                                    }
{   The entire contents of this file is protected by U.S. and        }
{   International Copyright Laws. Unauthorized reproduction,         }
{   reverse-engineering, and distribution of all or any portion of   }
{   the code contained in this file is strictly prohibited and may   }
{   result in severe civil and criminal penalties and will be        }
{   prosecuted to the maximum extent possible under the law.         }
{                                                                    }
{   RESTRICTIONS                                                     }
{                                                                    }
{   THIS SOURCE CODE AND ALL RESULTING INTERMEDIATE FILES            }
{   (DCU, OBJ, DLL, ETC.) ARE CONFIDENTIAL AND PROPRIETARY TRADE     }
{   SECRETS OF DEVELOPER EXPRESS INC. THE REGISTERED DEVELOPER IS    }
{   LICENSED TO DISTRIBUTE THE EXPRESSEDITORS AND ALL                }
{   ACCOMPANYING VCL CONTROLS AS PART OF AN EXECUTABLE PROGRAM ONLY. }
{                                                                    }
{   THE SOURCE CODE CONTAINED WITHIN THIS FILE AND ALL RELATED       }
{   FILES OR ANY PORTION OF ITS CONTENTS SHALL AT NO TIME BE         }
{   COPIED, TRANSFERRED, SOLD, DISTRIBUTED, OR OTHERWISE MADE        }
{   AVAILABLE TO OTHER INDIVIDUALS WITHOUT EXPRESS WRITTEN CONSENT   }
{   AND PERMISSION FROM DEVELOPER EXPRESS INC.                       }
{                                                                    }
{   CONSULT THE END USER LICENSE AGREEMENT FOR INFORMATION ON        }
{   ADDITIONAL RESTRICTIONS.                                         }
{                                                                    }
{********************************************************************}
unit cxRegExpr;

{$I cxVer.inc}

interface

uses
  SysUtils, Classes, cxClasses, cxEdit, cxEditConsts;

type
  { TcxRegExprError }

  TcxRegExprError = class
  private
    FChar: Integer;
    FLine: Integer;
    FMessage: string;
    function GetFullMessage: string;
  public
    constructor Create(ALine: Integer; AChar: Integer; AMessage: string);
    function Clone: TcxRegExprError;
    property Char: Integer read FChar;
    property FullMessage: string read GetFullMessage;
    property Line: Integer read FLine;
    property Message: string read FMessage; 
  end;

  { TcxRegExprErrors }

  TcxRegExprErrors = class
  private
    FErrors: TList;
    function GetCount: Integer;
    function GetItems(Index: Integer): TcxRegExprError;
  public
    constructor Create;
    destructor Destroy; override;
    procedure Add(AError: TcxRegExprError);
    procedure Clear;
    function Clone: TcxRegExprErrors;
    property Count: Integer read GetCount;
    property Items[Index: Integer]: TcxRegExprError read GetItems; default;
  end;

  { EcxRegExprError }

  EcxRegExprError = class(EcxEditError)
  private
    FErrors: TcxRegExprErrors;
  public
    constructor Create(AErrors: TcxRegExprErrors);
    property Errors: TcxRegExprErrors read FErrors;
  end;

  { TcxLexem }

  TcxLexem = record
    Char: Integer;
    Code: Integer;
    Line: Integer;
    Value: string;
  end;
  PcxLexem = ^TcxLexem;

  { TcxRegExprLexemCode }

  TcxRegExprLexemCode =
  (
    relcSymbol,
    relcSpecial,
    relcInteger,
    relcAll,
    relcId,
    relcNotId,
    relcDigit,
    relcNotDigit,
    relcSpace,
    relcNotSpace,
    relcReference,
    relcDateSeparator,
    relcTimeSeparator
  );

  { TcxLexems }

  TcxLexems = class
  private
    FLexems: TList;
    function GetCount: Integer;
    function GetItems(Index: Integer): TcxLexem;
  public
    constructor Create;
    destructor Destroy; override;
    procedure Add(ALexem: TcxLexem);
    procedure Clear;
    property Count: Integer read GetCount;
    property Items[Index: Integer]: TcxLexem read GetItems; default;
  end;

  { TcxRegExprItem }

  TcxRegExprItem = class
  public
    function Check(var AToken: Char; ACaseInsensitive: Boolean): Boolean; virtual; abstract;
    function Clone: TcxRegExprItem; virtual; abstract;
  end;

  { TcxRegExprSymbol }

  TcxRegExprSymbol = class(TcxRegExprItem)
  private
    FValue: Char;
  public
    constructor Create(AValue: Char);
    function Check(var AToken: Char; ACaseInsensitive: Boolean): Boolean; override;
    function Clone: TcxRegExprItem; override;
  end;

  { TcxRegExprTimeSeparator }

  TcxRegExprTimeSeparator = class(TcxRegExprItem)
  public
    function Check(var AToken: Char; ACaseInsensitive: Boolean): Boolean; override;
    function Clone: TcxRegExprItem; override;
    function Value: Char;
  end;

  { TcxRegExprDateSeparator }

  TcxRegExprDateSeparator = class(TcxRegExprItem)
  public
    function Check(var AToken: Char; ACaseInsensitive: Boolean): Boolean; override;
    function Clone: TcxRegExprItem; override;
    function Value: Char;    
  end;

  { TcxRegExprSubrange }

  TcxRegExprSubrange = class(TcxRegExprItem)
  private
    FStartValue: Char;
    FFinishValue: Char;
  public
    constructor Create(AStartValue: Char; AFinishValue: Char);
    function Check(var AToken: Char; ACaseInsensitive: Boolean): Boolean; override;
    function Clone: TcxRegExprItem; override;
  end;

  { TcxRegExprEnumeration }

  TcxRegExprEnumeration = class(TcxRegExprItem)
  private
    FInverse: Boolean;
  public
    constructor Create(AInverse: Boolean = False);
  end;

  { TcxRegExprUserEnumeration }

  TcxRegExprUserEnumeration = class(TcxRegExprEnumeration)
  private
    FItems: TList;
    function Item(AIndex: Integer): TcxRegExprItem;
  public
    constructor Create(AInverse: Boolean = False);
    destructor Destroy; override;
    procedure Add(AItem: TcxRegExprItem);
    function Check(var AToken: Char; ACaseInsensitive: Boolean): Boolean; override;
    function Clone: TcxRegExprItem; override;
  end;

  { TcxRegExprDigit }

  TcxRegExprDigit = class(TcxRegExprEnumeration)
  public
    constructor Create(AInverse: Boolean = False);
    function Check(var AToken: Char; ACaseInsensitive: Boolean): Boolean; override;
    function Clone: TcxRegExprItem; override;
  end;

  { TcxRegExprIdLetter }

  TcxRegExprIdLetter = class(TcxRegExprEnumeration)
  public
    constructor Create(AInverse: Boolean = False);
    function Check(var AToken: Char; ACaseInsensitive: Boolean): Boolean; override;
    function Clone: TcxRegExprItem; override;
  end;

  { TcxRegExprSpace }

  TcxRegExprSpace = class(TcxRegExprEnumeration)
  public
    constructor Create(AInverse: Boolean = False);
    function Check(var AToken: Char; ACaseInsensitive: Boolean): Boolean; override;
    function Clone: TcxRegExprItem; override;
  end;

  { TcxRegExprAll }

  TcxRegExprAll = class(TcxRegExprItem)
  public
    function Check(var AToken: Char; ACaseInsensitive: Boolean): Boolean; override;
    function Clone: TcxRegExprItem; override;
  end;

  TcxRegExprStates = class;

  { TcxRegExprState }

  TcxRegExprState = class
  protected
    FStates: TcxRegExprStates;
  public
    constructor Create;
    destructor Destroy; override;
    procedure Add(AState: TcxRegExprState); overload;
    procedure Add(AStates: TcxRegExprStates); overload;
    function Check(var AToken: Char; ACaseInsensitive: Boolean): TcxRegExprStates; virtual;
    function Clone: TcxRegExprState; virtual;
    function GetAllNextStates: TcxRegExprStates;
    function GetSelf: TcxRegExprStates; virtual;
    function Next(var AToken: Char; ACaseInsensitive: Boolean): TcxRegExprStates;
    property States: TcxRegExprStates read FStates;
  end;

  { TcxRegExprSimpleState }

  TcxRegExprSimpleState = class(TcxRegExprState)
  private
    FIsFinal: Boolean;
    FValue: TcxRegExprItem;
  public
    constructor Create(AValue: TcxRegExprItem);
    destructor Destroy; override;
    function Check(var AToken: Char; ACaseInsensitive: Boolean): TcxRegExprStates; override;
    function Clone: TcxRegExprState; override;
    function GetSelf: TcxRegExprStates; override;
    procedure SetFinal;
    property IsFinal: Boolean read FIsFinal;
  end;

  { TcxRegExprBlockState }

  TcxRegExprBlockState = class(TcxRegExprState)
  public
    function Check(var AToken: Char; ACaseInsensitive: Boolean): TcxRegExprStates; override;
    function Clone: TcxRegExprState; override;
    function GetSelf: TcxRegExprStates; override;
  end;

  { TcxRegExprStates }

  TcxRegExprStates = class
  private
    FStates: TList;
    function GetCount: Integer;
    function GetState(AIndex: Integer): TcxRegExprState;
  public
    constructor Create;
    destructor Destroy; override;
    procedure Add(AState: TcxRegExprState); overload;
    procedure Add(AStates: TcxRegExprStates); overload;
    procedure Clear;
    function Equ(var ASymbol: Char): Boolean;
    function GetAllNextStates: TcxRegExprStates;
    function IsFinal: Boolean;
    function Next(var AToken: Char; ACaseInsensitive: Boolean): TcxRegExprStates;
    property Count: Integer read GetCount;
    property State[AIndex: Integer]: TcxRegExprState read GetState; default;
  end;

  TcxRegExprParserAlts = class;
  TcxRegExpr = class;

  { TcxRegExprAutomat }

  TcxRegExprAutomat = class
  private
    FCurrentStates: TcxRegExprStates;
    FExpr: TcxRegExprParserAlts;
    FHistory: TList;
    FOwner: TcxRegExpr;
    FStartState: TcxRegExprSimpleState;
    function GetAllNextStates: TcxRegExprStates;
    function Pop: TcxRegExprStates;
    procedure Push(AStates: TcxRegExprStates);
  public
    constructor Create(AExpr: TcxRegExprParserAlts; AOwner: TcxRegExpr);
    destructor Destroy; override;
    function IsFinal: Boolean;
    function IsStart: Boolean;
    function Next(var AToken: Char; ACaseInsensitive: Boolean): Boolean;
    function Prev: Boolean;
    function Print: string;
    procedure Reset;
    procedure ReUpdate;
    procedure Update;
  end;

  { TcxRegExprQuantifier }

  TcxRegExprQuantifier = class
  public
    function CanMissing: Boolean; virtual; abstract;
    function CanRepeat: Boolean; virtual; abstract;
    function Clone: TcxRegExprQuantifier; virtual; abstract;
    function Print: string; virtual; abstract;
  end;

  { TcxRegExprSimpleQuantifier }

  TcxRegExprSimpleQuantifier = class(TcxRegExprQuantifier) // missing quantifier
  public
    function CanMissing: Boolean; override;
    function CanRepeat: Boolean; override;
    function Clone: TcxRegExprQuantifier; override;
    function Print: string; override;
  end;

  { TcxRegExprQuestionQuantifier }

  TcxRegExprQuestionQuantifier = class(TcxRegExprQuantifier) // ?
  public
    function CanMissing: Boolean; override;
    function CanRepeat: Boolean; override;
    function Clone: TcxRegExprQuantifier; override;
    function Print: string; override;
  end;

  { TcxRegExprStarQuantifier }

  TcxRegExprStarQuantifier = class(TcxRegExprQuantifier) // *
  public
    function CanMissing: Boolean; override;
    function CanRepeat: Boolean; override;
    function Clone: TcxRegExprQuantifier; override;
    function Print: string; override;
  end;

  { TcxRegExprPlusQuantifier }

  TcxRegExprPlusQuantifier = class(TcxRegExprQuantifier) // +
  public
    function CanMissing: Boolean; override;
    function CanRepeat: Boolean; override;
    function Clone: TcxRegExprQuantifier; override;
    function Print: string; override;
  end;

  { TcxRegExprParserItem }

  TcxRegExprParserItem = class
  private
    FQuantifier: TcxRegExprQuantifier;
  public
    constructor Create(AQuantifier: TcxRegExprQuantifier = nil);
    destructor Destroy; override;
    function CanEmpty: Boolean; virtual; abstract;
    function CanMissing: Boolean;
    function CanRepeat: Boolean;
    function Clone: TcxRegExprParserItem; virtual; abstract;
    function NotQuantifier: Boolean;
    function Print: string; virtual; abstract;
    procedure SetFinal; virtual; abstract;
    procedure SetQuantifier(AQuantifier: TcxRegExprQuantifier);
  end;

  { TcxRegExprParserSimpleItem }

  TcxRegExprParserSimpleItem = class(TcxRegExprParserItem)
  private
    FState: TcxRegExprState;
  public
    constructor Create(AState: TcxRegExprState; AQuantifier: TcxRegExprQuantifier = nil);
    destructor Destroy; override;
    function CanEmpty: Boolean; override;
    function Clone: TcxRegExprParserItem; override;
    function Print: string; override;
    procedure SetFinal; override;
    property State: TcxRegExprState read FState;
  end;

  TcxRegExprParserAlt = class;

  { TcxRegExprParserBlockItem }

  TcxRegExprParserBlockItem = class(TcxRegExprParserItem)
  private
    FAlts: TcxRegExprParserAlts;
    FFinishState: TcxRegExprState;
    FStartState: TcxRegExprState;
  public
    constructor Create(AQuantifier: TcxRegExprQuantifier = nil);
    destructor Destroy; override;
    function CanEmpty: Boolean; override;
    procedure CreateConnections;
    procedure AddAlt(AAlt: TcxRegExprParserAlt);
    procedure AddAlts(AAlts: TcxRegExprParserAlts);
    function Clone: TcxRegExprParserItem; override;
    function Print: string; override;
    procedure SetFinal; override;
    property Alts: TcxRegExprParserAlts read FAlts;
    property FinishState: TcxRegExprState read FFinishState;
    property StartState: TcxRegExprState read FStartState;
  end;

  { TcxRegExprParserAlt }

  TcxRegExprParserAlt = class
  private
    FItems: TList;
    function GetCount: Integer;
    function GetFirstItem: TcxRegExprParserItem;
    function GetItem(AIndex: Integer): TcxRegExprParserItem;
    function GetLastItem: TcxRegExprParserItem;
    procedure SetLastItem(AItem: TcxRegExprParserItem);
  public
    constructor Create;
    destructor Destroy; override;
    procedure Add(AItem: TcxRegExprParserItem);
    function CanEmpty: Boolean;
    function CanMissing: Boolean;
    function Clone: TcxRegExprParserAlt;
    procedure CreateConnections;
    procedure CreateFinalStates;
    function GetStartConnections: TcxRegExprStates;
    function Print: string;
    procedure SetFinishConnection(AFinishState: TcxRegExprState);
    property Count: Integer read GetCount;
    property FirstItem: TcxRegExprParserItem read GetFirstItem;
    property Item[AIndex: Integer]: TcxRegExprParserItem read GetItem; default;
    property LastItem: TcxRegExprParserItem read GetLastItem write SetLastItem;
  end;

  { TcxRegExprParserAlts }

  TcxRegExprParserAlts = class
  private
    FAlts: TList;
    function GetAlt(AIndex: Integer): TcxRegExprParserAlt;
    function GetCount: Integer;
    function GetLastAlt: TcxRegExprParserAlt;
  public
    constructor Create;
    destructor Destroy; override;
    procedure Add(AAlt: TcxRegExprParserAlt);
    procedure AddAlt;
    function CanEmpty: Boolean;
    procedure CreateConnections;
    procedure CreateFinalStates;
    function Clone: TcxRegExprParserAlts;
    function GetStartConnections: TcxRegExprStates;
    function Print: string;
    procedure SetFinishConnections(AFinishState: TcxRegExprState);
    function StartStateIsFinal: Boolean;
    function ThereIsEmptyAlt: Boolean;
    property Alt[AIndex: Integer]: TcxRegExprParserAlt read GetAlt; default;
    property Count: Integer read GetCount;
    property LastAlt: TcxRegExprParserAlt read GetLastAlt;
  end;

  TcxSymbolDeleteEvent = procedure of object;
  TcxSymbolUpdateEvent = procedure(ASymbol: Char) of object;

  { TcxRegExpr }
  
  TcxRegExpr = class
  private
    FAutomat: TcxRegExprAutomat;
    FBlocks: TList;
    FChar: Integer;
    FCaseInsensitive: Boolean;
    FCompiled: Boolean;
    FErrors: TcxRegExprErrors;
    FFirstExpr: Boolean;
    FIndex: Integer;
    FLexemIndex: Integer;
    FLexems: TcxLexems;
    FLine: Integer;
    FOnSymbolDelete: TcxSymbolDeleteEvent;
    FOnSymbolUpdate: TcxSymbolUpdateEvent;
    FStream: TMemoryStream;
    FUpdateOn: Boolean;
    procedure Clear;