unit dpglib.Alternative;

interface
uses
   dpgrtl.types,
   dpglib.types;

type
   // =========================================================================
   // Class TAlternative declaration
   // =========================================================================
   TAlternative = class(   TInterfacedObject,
                              IAlternative)
   protected
      // ------------------------------------------------------------
      // Head/Tail of AlternativeElem list
      // ------------------------------------------------------------
      fHead          : IAlternativeElem;
      fTail          : IAlternativeElem;

      // ------------------------------------------------------------
      // True if AST generation is on for this Alternative.
      // ------------------------------------------------------------
      fDoAutoGen     : boolean;

      // ------------------------------------------------------------
      // Syntactic predicate if any...
      // ------------------------------------------------------------
      fSynPredBlock  : ISynPredBlock;

      // ------------------------------------------------------------
      // Semantic predicate if any...
      // ------------------------------------------------------------
      fSemPred       : AnsiString;

      // ------------------------------------------------------------
      // Exception specification
      // ------------------------------------------------------------
      fExHandlerType : AnsiString;
      fExHandlerCode : AnsiString;

      // ------------------------------------------------------------
      // Lookahead for alternative. Filled in by deterministic() only
      // Used for code gen after calls to deterministic() and used by
      // deterministic() for (...)*, (...)+ and (...)? blocks. 1..k.
      // ------------------------------------------------------------
      fCache         : array of ILookahead;

      // ------------------------------------------------------------
      // Each alt has different lookahead depth possibly. Depth can
      // be NONDETERMINISTIC too. 0..n-1.
      // ------------------------------------------------------------
      fLookaheadDepth: integer;

      // ------------------------------------------------------------
      // Tree specification a'la -> A B C (not implemented)
      // ------------------------------------------------------------
      fTreeSpecifier : IToken;

   public
      // ------------------------------------------------------------
      // Constructor/destructor
      // ------------------------------------------------------------
      constructor Create;                                   overload;
      constructor Create( pFirstElem: IAlternativeElem); overload;
      destructor  Destroy; override;
      
      // ------------------------------------------------------------
      // IAlternative methods
      // ------------------------------------------------------------
   protected
      function    GetHead             : IAlternativeElem;
      function    GetTail             : IAlternativeElem;
      function    GetSynPredBlock     : ISynPredBlock;
      function    GetSemPred          : AnsiString;

      function    GetExHandlerType    : AnsiString;
      function    GetExHandlerCode    : AnsiString;

      function    GetCacheSize        : integer;
      function    GetLookaheadDepth   : integer;
      function    GetTreeSpecifier    : IToken;
      function    GetDoAutoGen        : boolean;

      procedure   SetHead(            pHead          : IAlternativeElem);
      procedure   SetTail(            pTail          : IAlternativeElem);

      procedure   SetSynPredBlock(    pBlock         : ISynPredBlock);
      procedure   SetSemPred(         pSemPred       : AnsiString);

      procedure   SetExHandlerType(   pType          : AnsiString);
      procedure   SetExHandlerCode(   pCode          : AnsiString);
      
      procedure   SetCacheSize(       pSize          : integer);
      procedure   SetLookaheadDepth(  pDepth         : integer);
      procedure   SetTreeSpecifier(   pTreeSpecifier : IToken);
      procedure   SetDoAutoGen(       pDoAutoGen     : boolean);
      
      function    GetCache( i:integer): ILookahead;
      procedure   SetCache( i: integer; pLookahead: ILookahead);

   public
      procedure   AddElem( pElem: IAlternativeElem);
      function    AtStart: boolean;

   end;

implementation

// ****************************************************************************
//                                                       Constructor/destructor
// ****************************************************************************
// ----------------------------------------------------------------------------
// Constructor
// ----------------------------------------------------------------------------
constructor TAlternative.Create;
begin
   inherited Create;
end;

// ----------------------------------------------------------------------------
// Constructor
// ----------------------------------------------------------------------------
constructor TAlternative.Create(pFirstElem: IAlternativeElem);
begin
   inherited Create;
   AddElem( pFirstElem);
end;

// ----------------------------------------------------------------------------
// Destructor
// ----------------------------------------------------------------------------
destructor TAlternative.Destroy;
begin
   fHead          := nil;
   fTail          := nil;
   fSynPredBlock  := nil;
   fTreeSpecifier := nil;

//!!   fCache         := nil;
   inherited;
end;

// ****************************************************************************
// IAlternative implementation
// ****************************************************************************
// ----------------------------------------------------------------------------
// GetHead
// ----------------------------------------------------------------------------
function TAlternative.GetHead: IAlternativeElem;
begin
   result := fHead;
end;

// ----------------------------------------------------------------------------
// GetTail
// ----------------------------------------------------------------------------
function TAlternative.GetTail: IAlternativeElem;
begin
   result := fTail;
end;

// ----------------------------------------------------------------------------
// GetSynPredBlock
// ----------------------------------------------------------------------------
function TAlternative.GetSynPredBlock: ISynPredBlock;
begin
   result := fSynPredBlock;
end;

// ----------------------------------------------------------------------------
// GetSemPred
// ----------------------------------------------------------------------------
function TAlternative.GetSemPred: AnsiString;
begin
   result := fSemPred;
end;

// ----------------------------------------------------------------------------
// GetCacheSize
// ----------------------------------------------------------------------------
function TAlternative.GetCacheSize: integer;
begin
   result := High(fCache) - Low(fCache);
end;

// ----------------------------------------------------------------------------
// GetCache
// ----------------------------------------------------------------------------
function TAlternative.GetCache(i: integer): ILookahead;
begin
   result := fCache[i];
end;

// ----------------------------------------------------------------------------
// GetLookaheadDepth
// ----------------------------------------------------------------------------
function TAlternative.GetLookaheadDepth: integer;
begin
   result := fLookaheadDepth;
end;

// ----------------------------------------------------------------------------
// GetTreeSpecifier
// ----------------------------------------------------------------------------
function TAlternative.GetTreeSpecifier: IToken;
begin
   result := fTreeSpecifier;
end;

// ----------------------------------------------------------------------------
// GetAutoGen
//
// Don't build an AST if there is a tree-rewrite-specifier.
// ----------------------------------------------------------------------------
function TAlternative.GetDoAutoGen: boolean;
begin
   result := fDoAutoGen and (fTreeSpecifier = nil);
end;

// ----------------------------------------------------------------------------
// SetTail
// ----------------------------------------------------------------------------
procedure TAlternative.SetTail(pTail: IAlternativeElem);
begin
   fTail := pTail;
end;

// ----------------------------------------------------------------------------
// SetHead
// ----------------------------------------------------------------------------
procedure TAlternative.SetHead(pHead: IAlternativeElem);
begin
   fHead := pHead;
end;

// ----------------------------------------------------------------------------
// SetSynPredBlock
// ----------------------------------------------------------------------------
procedure TAlternative.SetSynPredBlock(pBlock: ISynPredBlock);
begin
   fSynPredBlock := pBlock;
end;

// ----------------------------------------------------------------------------
// SetSemPred
// ----------------------------------------------------------------------------
procedure TAlternative.SetSemPred(pSemPred: AnsiString);
begin
   fSemPred := pSemPred;
end;

// ----------------------------------------------------------------------------
// SetCacheSize
// ----------------------------------------------------------------------------
procedure TAlternative.SetCacheSize(pSize: integer);
begin
   SetLength( fCache, pSize);
end;

// ----------------------------------------------------------------------------
// SetCache
// ----------------------------------------------------------------------------
procedure TAlternative.SetCache(i: integer; pLookahead: ILookahead);
begin
   fCache[i] := pLookahead;
end;

// ----------------------------------------------------------------------------
// SetLookaheadDepth
// ----------------------------------------------------------------------------
procedure TAlternative.SetLookaheadDepth(pDepth: integer);
begin
   fLookaheadDepth := pDepth;
end;

// ----------------------------------------------------------------------------
// SetTreeSpecifier
// ----------------------------------------------------------------------------
procedure TAlternative.SetTreeSpecifier(pTreeSpecifier: IToken);
begin
   fTreeSpecifier := pTreeSpecifier;
end;

// ----------------------------------------------------------------------------
// SetDoAutoGen
// ----------------------------------------------------------------------------
procedure TAlternative.SetDoAutoGen(pDoAutoGen: boolean);
begin
   fDoAutoGen := pDoAutoGen;
end;

// ----------------------------------------------------------------------------
// AddElem
// ----------------------------------------------------------------------------
procedure TAlternative.AddElem(pElem: IAlternativeElem);
begin
   if fHead = nil then
   begin
      fHead       := pElem;
      fTail       := pElem;
   end
   else
   begin
      fTail.Next  := pElem;
      fTail       := pElem;
   end;
end;

// ----------------------------------------------------------------------------
// AtStart
// ----------------------------------------------------------------------------
function TAlternative.AtStart: boolean;
begin
   result := fHead = nil;
end;

function TAlternative.GetExHandlerCode: AnsiString;
begin
   result := fExHandlerCode;
end;

function TAlternative.GetExHandlerType: AnsiString;
begin
   result := fExHandlerType;
end;

procedure TAlternative.SetExHandlerCode(pCode: AnsiString);
begin
   fExHandlerCode := pCode;
end;

procedure TAlternative.SetExHandlerType(pType: AnsiString);
begin
   fExHandlerType := pType;
end;

end.