bds.mr.dpg/src.lib/dpglib.LexerGrammar.pas

unit dpglib.LexerGrammar;

interface
uses
   System.Classes,
   System.Contnrs,
   dpgrtl.types,
   dpglib.Types,
   dpglib.Grammar;

type
   // =========================================================================
   // Class TLexerGrammar
   // =========================================================================
   TLexerGrammar = class(  TGrammar,
                              IGrammar,
                              ILexerGrammar)
   protected
      fTestLiterals           : boolean;
      fCaseSensitive          : boolean;
      fFilterMode             : boolean;
      fFilterRule             : AnsiString;

   public
      // ------------------------------------------------------------
      // Constructor/destructor
      // ------------------------------------------------------------
      constructor Create(     pObjectName    : IToken;
                              pTool          : ITool;
                              pSuperName     : IToken);

      // ------------------------------------------------------------
      // IGrammar overrides
      // ------------------------------------------------------------
      function    SetOption(  pOption        : IToken;
                              pValue         : IToken): boolean;

      // ------------------------------------------------------------
      // ILexerGrammar methoda
      // ------------------------------------------------------------
      function    GetTestLiterals           : boolean;
      function    GetCaseSensitive          : boolean;
      function    GetFilterMode             : boolean;
      function    GetFilterRule             : AnsiString;

   end;

implementation
uses
   System.SysUtils,
   dpglib.DpgLexerTokens,
   dpglib.Messages;

// ****************************************************************************
//                                                       Constructor/destructor
// ****************************************************************************
// ============================================================================
// Constructor
// ============================================================================
constructor TLexerGrammar.Create(   pObjectName : IToken;
                                       pTool       : ITool;
                                       pSuperName  : IToken);
begin
   inherited;

   fTestLiterals           := false;
   fCaseSensitive          := true;
   fFilterMode             := false;

   // ---------------------------------------------------------------
   // Lexer usually has no default handling
   // ---------------------------------------------------------------
   fDefErrorHandler        := false;
end;

// ****************************************************************************
//                                              ILexerGrammar implementation
// ****************************************************************************
// ============================================================================
// GetTestLiterals
// ============================================================================
function TLexerGrammar.GetTestLiterals: boolean;
begin
   result := fTestLiterals;
end;

// ============================================================================
// GetCaseSensitive
// ============================================================================
function TLexerGrammar.GetCaseSensitive: boolean;
begin
   result := fCaseSensitive;
end;

// ============================================================================
// GetFilterMode
// ============================================================================
function TLexerGrammar.GetFilterMode: boolean;
begin
   result := fFilterMode;
end;

// ============================================================================
// GetFilterRule
// ============================================================================
function TLexerGrammar.GetFilterRule: AnsiString;
begin
   result := fFilterRule;
end;

// ****************************************************************************
//                                                        IGrammar overrides
// ****************************************************************************
// ============================================================================
// SetOption
//
// Option               Value
// -------------------------------------------------------
// testLiterals         true/false
// caseSensitive        true/false
// filter               true/false/ID
// ============================================================================
function TLexerGrammar.SetOption(pOption, pValue: IToken): boolean;
begin
   result := true;

   // ---------------------------------------------------------------
   // Option: testLiterals
   // ---------------------------------------------------------------
   if pOption.TokenText = 'testLiterals' then
   begin
      if pValue.TokenText = 'true' then
         fTestLiterals := true

      else if pValue.TokenText = 'false' then
         fTestLiterals := false

      else
      begin
         fTool.Error('Value for "testLiterals" must be true or false',
                     fGrammarFile,
                     pValue.TokenLine,
                     pValue.TokenColumn);

         result := false;
      end;
   end

   // ---------------------------------------------------------------
   // Option: defaultErrorHandler
   // ---------------------------------------------------------------
   else if pOption.TokenText = 'defaultErrorHandler' then
   begin
      fTool.Warning( 'Option "defaultErrorHandler" is invalid for lexer',
                     fGrammarFile,
                     pValue.TokenLine,
                     pValue.TokenColumn);
      result := true;
   end

   // ---------------------------------------------------------------
   // Option: caseSensitive
   // ---------------------------------------------------------------
   else if pOption.TokenText = 'caseSensitive' then
   begin
      if pValue.TokenText = 'true' then
         fCaseSensitive := true

      else if pValue.TokenText = 'false' then
         fCaseSensitive := false

      else
      begin
         fTool.Error('Value for "caseSensitive" must be true or false',
                     fGrammarFile,
                     pValue.TokenLine,
                     pValue.TokenColumn);

         result := false;
      end;
   end

   // ---------------------------------------------------------------
   // Option: filter
   // ---------------------------------------------------------------
   else if pOption.TokenText = 'filter' then
   begin
      if pValue.TokenText = 'true' then
      begin
         fFilterMode := true;
         fFilterRule := '';
      end

      else if pValue.TokenText = 'false' then
      begin
         fFilterMode := false;
         fFilterRule := '';
      end

      else if pValue.TokenType in [TT_TOKENREF] then
      begin
         fFilterMode := true;
         fFilterRule := pValue.TokenText;
      end

      else
      begin
         fTool.Error('Value for "filter" must be true or false or an identifier.',
                     fGrammarFile,
                     pValue.TokenLine,
                     pValue.TokenColumn);

         result := false;
      end;
   end

   else
      result := inherited SetOption(pOption, pValue);
end;

end.