Auto

unit UIfTree;

interface

uses System.Generics.Collections, UData, SysUtils;

type
   TPNode = ^TTreeNode;
   TTreeNode = record
      ThenBranch: TPNode;
      ElseBranch: TPNode;
      Next: TPNode;
   end;
   TTreeMaker = class
   type
      TFunc = procedure of object;
      TStateArr = array [0..6] of TFunc;
   const
      IF_STAT = 0;
      AFTER_IF_STAT = 1;
      BRACKET_STAT = 2;
      ELSE_STAT = 3;
      CASE_STAT = 4;
      EXIT_STAT = 5;
      SEARCHING_STAT = 6;
      NO_BRAC_ELSE_STAT = -1;

   public
      constructor Create(CodeBuffer: TTokenArr; Size: Integer);
      destructor Free;
   private
      Buffer: TTokenArr;
      State: Integer;
      ArrIndex: Integer;
      Size: Integer;
      TempNode: TPNode;
      StateStack: TStack<Integer>;
      IfStack: TStack<TPNode>;
      StateArr: TStateArr;
      PHead: TPNode;
      property Head: TPNode read PHead;
      procedure SearchingForIf();
      procedure FindIf();
      procedure CaseStatement();
      procedure AfterIf();
      procedure ClosingBracket();
      procedure AfterElse();
      procedure IgnoreCondition;
//      procedure Finish();
//      const
//         StateArr: array [0..3] of  TFunc = (SearchingForIf(), AfterIf(), ClosingBracket(), AfterElse());
   end;

implementation

constructor TTreeMaker.Create(CodeBuffer: TTokenArr; Size: Integer);
//var
//  i: Integer;
begin
   Self.Buffer := CodeBuffer;
   Self.Size := Size;
   Self.State := SEARCHING_STAT;
   Self.StateStack := TStack<Integer>.Create;
   Self.IfStack := TStack<TPNode>.Create;
   ArrIndex := 0;
   New(TempNode);
   TempNode^.Next := nil;
   PHead := TempNode;
   StateArr[IF_STAT] := FindIf;
   StateArr[AFTER_IF_STAT] := AfterIf;
   StateArr[BRACKET_STAT] := ClosingBracket;
   StateArr[ELSE_STAT] := AfterElse;
   StateArr[CASE_STAT] := CaseStatement;
//   StateArr[EXIT_STAT] := Finish;
   StateArr[SEARCHING_STAT] := SearchingForIf;
   StateStack.Push(BRACKET_STAT);
   StateArr[State];
end;


procedure TTreeMaker.IgnoreCondition;
begin
   while AnsiCompareStr(Buffer[ArrIndex], '{') <> 0 do
   begin
      Inc(ArrIndex);
   end;
end;

function IsIfEquals(Arg: string): Boolean;
begin
   if (AnsiCompareStr(Arg, 'if') = 0) or (AnsiCompareStr(Arg, 'for') = 0) or
      (AnsiCompareStr(Arg, 'while') = 0) then
      Result := True
    else
      Result := False;
end;

procedure TTreeMaker.SearchingForIf;
begin
   while ArrIndex < Size do
   begin
      if IsIfEquals(Buffer[ArrIndex]) then
      begin
         StateArr[IF_STAT];
      end;
      Inc(ArrIndex);
   end;
   StateStack.Clear;
   IfStack.Clear;
end;

procedure TTreeMaker.FindIf;
var
   Temp: TPNode;
//   TempState: Integer;
begin
   Inc(ArrIndex);
   New(Temp);
   Temp^.ThenBranch := nil;
   Temp^.ElseBranch := nil;
   Temp^.Next := nil;
   IfStack.Push(Temp);
   if StateStack.Count > 0 then
      State := StateStack.Pop;
   case State of
      AFTER_IF_STAT: TempNode.ThenBranch := Temp;
      ELSE_STAT: TempNode.ElseBranch := Temp;
      BRACKET_STAT: TempNode.Next := Temp;
   end;
   TempNode := Temp;
   State := AFTER_IF_STAT;
   StateStack.Push(State);
   if ArrIndex < Size then
      StateArr[State];
end;


procedure TTreeMaker.AfterIf;
var
   StateNotFound: Boolean;
begin
   StateNotFound := True;
   IgnoreCondition;
   while StateNotFound and (ArrIndex < Size) do
   begin
      if AnsiCompareStr(Buffer[ArrIndex], '}') = 0 then
      begin
         State := BRACKET_STAT;
         StateNotFound := False;
      end
      else
         if IsIfEquals(Buffer[ArrIndex]) then
         begin
            State := IF_STAT;
            StateNotFound := False;
         end;
      Inc(ArrIndex);
   end;
   if ArrIndex < Size then
      StateArr[State];
end;


procedure TTreeMaker.ClosingBracket;
var
   Temp: Integer;
begin
   State := BRACKET_STAT;
   StateStack.Pop;
   if AnsiCompareStr(Buffer[ArrIndex + 1], 'else') = 0 then
   begin
      Inc(ArrIndex, 2);
      if ArrIndex < Size then
         StateArr[State];
   end
   else
   begin
      TempNode := IfStack.Pop;
      if StateStack.Count > 0 then
         Temp := StateStack.Pop
      else
         Temp := State;
      if Temp = NO_BRAC_ELSE_STAT then
         TempNode := IfStack.Pop
      else
         StateStack.Push(Temp);
      StateStack.Push(BRACKET_STAT);
      Inc(ArrIndex);
      if ArrIndex < Size then
         StateArr[SEARCHING_STAT];
   end;
end;


procedure TTreeMaker.AfterElse;
var
   StateNotFound: Boolean;
begin
   State := ELSE_STAT;
   if StateStack.Count > 0 then
      StateStack.Pop;
   StateStack.Push(State);
   StateNotFound := True;
   if AnsiCompareStr(Buffer[ArrIndex], '{') = 0 then
   begin
      while StateNotFound and (ArrIndex < Size) do
      begin
         Inc(ArrIndex);
         if AnsiCompareStr(Buffer[ArrIndex], '}') = 0 then
         begin
            State := BRACKET_STAT;
         end
         else
            begin
               State := SEARCHING_STAT;
            end;
      end;
   end
   else
      if IsIfEquals(Buffer[ArrIndex]) then
      begin
         State := IF_STAT;
         StateStack.Push(NO_BRAC_ELSE_STAT);
         Inc(ArrIndex);
      end;
   if ArrIndex < Size then
      StateArr[State];
end;

procedure TTreeMaker.CaseStatement;
begin

end;

//procedure Finish();
//begin
//
//end;


destructor TTreeMaker.Free;
begin
   StateStack.Destroy;
   IfStack.Destroy;
end;


end.
//