Changeset 50 for trunk/Compiler/Target/Interpretter/UTargetInterpretter.pas

Timestamp:

Apr 5, 2012, 2:03:52 PM (13 years ago)

Author:

chronos

Message:

• Modified: Interpretter execution partial implementation.

File:

• trunk/Compiler/Target/Interpretter/UTargetInterpretter.pas (modified) (2 diffs)

trunk/Compiler/Target/Interpretter/UTargetInterpretter.pas

@@ -6 +6 @@
 
 uses
-  Classes, SysUtils, UTarget, UExecutor;
+  Classes, SysUtils, UTarget, UExecutor, USourceCode, Dialogs;
 
 type
-
   { TTargetInterpretter }
 
   TTargetInterpretter = class(TTarget)
     constructor Create; override;
+    destructor Destroy; override;
   end;
 
+  { TExecutorInterpretter }
+
   TExecutorInterpretter = class(TExecutor)
-
+  private
+    procedure RunCommand(Command: TCommand);
+    procedure RunBeginEnd(BeginEnd: TBeginEnd);
+    procedure RunWhileDo(WhileDo: TWhileDo);
+    procedure RunRepeatUntil(RepeatUntil: TRepeatUntil);
+    procedure RunIfThenElse(IfThenElse: TIfThenElse);
+    procedure RunAssignment(Assignment: TAssignment);
+    procedure RunCaseOfEnd(CaseOfEnd: TCaseOfEnd);
+    procedure RunFunction(FunctionCall: TFunctionCall);
+    procedure RunForToDo(ForToDo: TForToDo);
+    function Evaluate(Expression: TExpression): Boolean;
+  public
+    procedure Run; override;
   end;
 
+
 implementation
+
+uses
+  UCompiler;
+
+resourcestring
+  SUnknownCommandType = 'Unknown command type';
+
+{ TExecutorInterpretter }
+
+procedure TExecutorInterpretter.RunCommand(Command: TCommand);
+begin
+  if Command is TBeginEnd then RunBeginEnd(TBeginEnd(Command))
+  else if Command is TWhileDo then RunWhileDo(TWhileDo(Command))
+  else if Command is TRepeatUntil then RunRepeatUntil(TRepeatUntil(Command))
+  else if Command is TIfThenElse then RunIfThenElse(TIfThenElse(Command))
+  else if Command is TAssignment then RunAssignment(TAssignment(Command))
+  else if Command is TCaseOfEnd then RunCaseOfEnd(TCaseOfEnd(Command))
+  else if Command is TFunctionCall then RunFunction(TFunctionCall(Command))
+  else if Command is TForToDo then RunForToDo(TForToDo(Command))
+  else raise Exception.Create(SUnknownCommandType);
+end;
+
+procedure TExecutorInterpretter.RunBeginEnd(BeginEnd: TBeginEnd);
+var
+  I: Integer;
+begin
+  for I := 0 to BeginEnd.Commands.Count - 1 do
+    RunCommand(TCommand(BeginEnd.Commands[I]))
+end;
+
+procedure TExecutorInterpretter.RunWhileDo(WhileDo: TWhileDo);
+begin
+  while Evaluate(WhileDo.Condition) do RunBeginEnd(WhileDo.CommonBlock.Code);
+end;
+
+procedure TExecutorInterpretter.RunRepeatUntil(RepeatUntil: TRepeatUntil);
+begin
+  repeat
+    RunBeginEnd(RepeatUntil.CommonBlock.Code);
+  until Evaluate(RepeatUntil.Condition);
+end;
+
+procedure TExecutorInterpretter.RunIfThenElse(IfThenElse: TIfThenElse);
+begin
+  if Evaluate(IfThenElse.Condition) then RunCommand(IfThenElse.Command)
+    else RunCommand(IfThenElse.ElseCommand);
+end;
+
+procedure TExecutorInterpretter.RunAssignment(Assignment: TAssignment);
+begin
+  //Assignment.Target := Assignment.Source;
+end;
+
+procedure TExecutorInterpretter.RunCaseOfEnd(CaseOfEnd: TCaseOfEnd);
+var
+  I: Integer;
+begin
+ (* I := 0;
+  while (I < CaseOfEnd.Branches.Count) and
+    if TCaseOfEndBranche(CaseOfEnd.Branches[I]).Constant =
+      Evaluate(CaseOfEnd.Expression) do
+      Inc(I);
+  if (I < CaseOfEnd.Branches.Count) then
+    RunCommand(TCaseOfEndBranche(CaseOfEnd.Branches[I]).Command)
+    else RunCommand(CaseOfEnd.ElseCommand); *)
+end;
+
+procedure TExecutorInterpretter.RunFunction(FunctionCall: TFunctionCall);
+begin
+  RunBeginEnd(FunctionCall.FunctionRef.Code);
+end;
+
+procedure TExecutorInterpretter.RunForToDo(ForToDo: TForToDo);
+var
+  I: Integer;
+begin
+(*  for I := 0 to ForToDo.Start to ForToDo.Stop do begin
+    ForToDo.ControlVariable.;
+    RunCommand(ForToDo.Command);
+  end; *)
+end;
+
+function TExecutorInterpretter.Evaluate(Expression: TExpression): Boolean;
+begin
+//  case Expression.NodeType of
+//    ntConstant: ;
+//  end;
+end;
+
+procedure TExecutorInterpretter.Run;
+begin
+  ShowMessage(TModuleProgram(TCompiler(TTarget(Target).Compiler).Analyzer.ProgramCode.Modules[0]).Name);
+  with TModuleProgram(TCompiler(TTarget(Target).Compiler).Analyzer.ProgramCode.Modules[0]) do begin
+    RunBeginEnd(Body.Code);
+  end;
+end;
 
 { TTargetInterpretter }
@@ -30 +141 @@
   Name := 'Interpretter';
   Executor := TExecutorInterpretter.Create;
+  Executor.Target := Self;
+end;
+
+destructor TTargetInterpretter.Destroy;
+begin
+  FreeAndNil(Executor);
+  inherited Destroy;
 end;