Changeset 147

Timestamp:

Jan 17, 2018, 3:34:13 PM (6 years ago)

Author:

chronos

Message:

• Added: Support for Repeat blocks and Break command.

Location:

branches/easy compiler

Files:

• Steps.txt (modified) (1 diff)
• UCompiler.pas (modified) (3 diffs)
• UFormMain.pas (modified) (1 diff)
• USourceCode.pas (modified) (5 diffs)
• USourceExecutor.pas (modified) (6 diffs)
• USourceGenerator.pas (modified) (4 diffs)

branches/easy compiler/Steps.txt

@@ -20 +20 @@
 Add begin-end block support
 - local variables, constants, types
-
+Add ifzero support
+- if condition is valid then skip next command
+Add Repeat keyword
+- can be exited by Break command and reiterated by Continue
 
 TODO:

branches/easy compiler/UCompiler.pas

@@ -44 +44 @@
     procedure Parse(Code: TSourceCode);
     function ParseBeginEnd(SourceCode: TSourceCode; out BeginEnd: TCommandBeginEnd): Boolean;
+    function ParseBreak(SourceCode: TSourceCode; out CommandBreak: TCommandBreak
+      ): Boolean;
+    function ParseCommand(SourceCode: TSourceCode; out Command: TSourceCommand
+      ): Boolean;
     function ParseFunctionCall(SourceCode: TSourceCode; out FunctionCall: TCommandFunctionCall): Boolean;
     function ParseIfZero(SourceCode: TSourceCode; out IfZero: TCommandIfZero): Boolean;
     function ParseReference(SourceCode: TSourceCode): TSourceReference;
     function ParseReferenceVariable(SourceCode: TSourceCode): TSourceReference;
+    function ParseRepeat(SourceCode: TSourceCode; out
+      CommandRepeat: TCommandRepeat): Boolean;
     function ParseVar(SourceCode: TSourceCode): Boolean;
   public
@@ -306 +312 @@
   if Keyword = 'ifzero' then begin
     IfZero := TCommandIfZero.Create;
-    IfZero.Variable := TSourceReferenceVariable(ParseReferenceVariable(SourceCode)).Variable;
-    Result := True;
-  end;
-  if not Result then Tokenizer.TokenIndex := TokenIndex;
-end;
-
-function TCompiler.ParseBeginEnd(SourceCode: TSourceCode; out BeginEnd: TCommandBeginEnd): Boolean;
-var
-  Token: TSourceToken;
+    IfZero.Variable := TSourceReferenceVariable(ParseReferenceVariable(SourceCode));
+    Result := True;
+  end;
+  if not Result then Tokenizer.TokenIndex := TokenIndex;
+end;
+
+function TCompiler.ParseBreak(SourceCode: TSourceCode; out CommandBreak: TCommandBreak): Boolean;
+var
+  Token: TSourceToken;
+  TokenIndex: Integer;
   Keyword: string;
-  TokenIndex: Integer;
+begin
+  Result := False;
+  TokenIndex := Tokenizer.TokenIndex;
+  Token := Tokenizer.GetNext;
+  Keyword := LowerCase(Token.Text);
+  if Keyword = 'break' then begin
+    CommandBreak := TCommandBreak.Create;
+    Result := True;
+  end;
+  if not Result then Tokenizer.TokenIndex := TokenIndex;
+end;
+
+function TCompiler.ParseRepeat(SourceCode: TSourceCode; out CommandRepeat: TCommandRepeat): Boolean;
+var
+  Token: TSourceToken;
+  TokenIndex: Integer;
+  Keyword: string;
+  Command: TSourceCommand;
+begin
+  Result := False;
+  TokenIndex := Tokenizer.TokenIndex;
+  Token := Tokenizer.GetNext;
+  Keyword := LowerCase(Token.Text);
+  if Keyword = 'repeat' then begin
+    CommandRepeat := TCommandRepeat.Create;
+    if ParseCommand(SourceCode, Command) then begin
+      CommandRepeat := TCommandRepeat.Create;
+      CommandRepeat.Command := Command;
+      Command.Parent := CommandRepeat;
+    end else
+    raise Exception.Create('Unexpected token');
+    Result := True;
+  end;
+  if not Result then Tokenizer.TokenIndex := TokenIndex;
+end;
+
+function TCompiler.ParseCommand(SourceCode: TSourceCode; out Command: TSourceCommand): Boolean;
+var
   CommandBeginEnd: TCommandBeginEnd;
   CommandIfZero: TCommandIfZero;
   CommandFunctionCall: TCommandFunctionCall;
+  CommandBreak: TCommandBreak;
+  CommandRepeat: TCommandRepeat;
+begin
+  Command := nil;
+  Result := True;
+  if ParseVar(SourceCode) then else
+  if ParseBeginEnd(SourceCode, CommandBeginEnd) then begin
+    Command := CommandBeginEnd;
+  end else
+  if ParseIfZero(SourceCode, CommandIfZero) then begin
+    Command := CommandIfZero;
+  end else
+  if ParseBreak(SourceCode, CommandBreak) then begin
+    Command := CommandBreak;
+  end else
+  if ParseRepeat(SourceCode, CommandRepeat) then begin
+    Command := CommandRepeat;
+  end else
+  if ParseFunctionCall(SourceCode, CommandFunctionCall) then begin
+    Command := CommandFunctionCall;
+  end else Result := False;
+end;
+
+function TCompiler.ParseBeginEnd(SourceCode: TSourceCode; out BeginEnd: TCommandBeginEnd): Boolean;
+var
+  Token: TSourceToken;
+  Keyword: string;
+  TokenIndex: Integer;
+  Command: TSourceCommand;
 begin
   Result := False;
@@ -329 +402 @@
     BeginEnd.SourceCode := SourceCode;
     while True do begin
-      if ParseVar(SourceCode) then
-      else if ParseBeginEnd(SourceCode, CommandBeginEnd) then
-        BeginEnd.Instructions.Add(CommandBeginEnd)
-      else if ParseIfZero(SourceCode, CommandIfZero) then
-        BeginEnd.Instructions.Add(CommandIfZero)
-      else if ParseFunctionCall(SourceCode, CommandFunctionCall) then
-        BeginEnd.Instructions.Add(CommandFunctionCall)
-      else if Tokenizer.CheckNext('end', stIdentifier) then begin
+      if ParseCommand(SourceCode, Command) then begin
+        if Assigned(Command) then begin
+          BeginEnd.Commands.Add(Command);
+          Command.Parent := BeginEnd;
+        end;
+      end else
+      if Tokenizer.CheckNext('end', stIdentifier) then begin
         Break;
-      end
-      else raise Exception.Create('Unknown token: ' + Keyword);
+      end else begin
+        Token := Tokenizer.GetNext;
+        Keyword := LowerCase(Token.Text);
+        raise Exception.Create('Unknown token: ' + Keyword);
+      end;
     end;
     Token := Tokenizer.GetNext;

branches/easy compiler/UFormMain.pas

@@ -55 +55 @@
     Add('var I Integer');
     Add('Assign I 10');
-    //Add('Repeat');
+    Add('Repeat');
     Add('Begin');
-    //Add('Decrement I 1');
+    Add('PrintLn I');
+    Add('Decrement I 1');
     Add('IfZero I');
-    Add('Print ''condition''');
-    //Add('Break');
+    Add('Break');
     Add('End');
     Add('End');

branches/easy compiler/USourceCode.pas

@@ -10 +10 @@
 type
   TSourceCommand = class
-  end;
-
-  TSourceInstructions = class(TObjectList)
+    Parent: TSourceCommand;
+  end;
+
+  TSourceCommands = class(TObjectList)
   end;
 
@@ -140 +141 @@
   TCommandBeginEnd = class(TSourceCommand)
     SourceCode: TSourceCode;
-    Instructions: TSourceInstructions;
+    Commands: TSourceCommands;
     constructor Create;
     destructor Destroy; override;
   end;
 
+  { TCommandIfZero }
+
   TCommandIfZero = class(TSourceCommand)
-    Variable: TSourceVariable;
+    Variable: TSourceReferenceVariable;
+    destructor Destroy; override;
+  end;
+
+  { TCommandRepeat }
+
+  TCommandRepeat = class(TSourceCommand)
+    Command: TSourceCommand;
+    destructor Destroy; override;
+  end;
+
+  TCommandBreak = class(TSourceCommand)
+  end;
+
+  TCommandContinue = class(TSourceCommand)
   end;
 
@@ -167 +184 @@
 implementation
 
+{ TCommandIfZero }
+
+destructor TCommandIfZero.Destroy;
+begin
+  Variable.Free;
+  inherited Destroy;
+end;
+
+{ TCommandRepeat }
+
+destructor TCommandRepeat.Destroy;
+begin
+  Command.Free;
+  inherited Destroy;
+end;
+
 { TSourceConstant }
 
@@ -192 +225 @@
 constructor TCommandBeginEnd.Create;
 begin
-  Instructions := TSourceInstructions.Create;
+  Commands := TSourceCommands.Create;
 end;
 
 destructor TCommandBeginEnd.Destroy;
 begin
-  Instructions.Free;
+  Commands.Free;
   inherited Destroy;
 end;
@@ -388 +421 @@
 
   Funct := Functions.AddNew('increment');
+  Funct.AddParameter('Variable', pkVariable);
+  Funct.AddParameter('Addition', pkString);
+
+  Funct := Functions.AddNew('decrement');
   Funct.AddParameter('Variable', pkVariable);
   Funct.AddParameter('Addition', pkString);

branches/easy compiler/USourceExecutor.pas

@@ -22 +22 @@
   TExecutorVariables = class(TObjectList)
     function Search(Variable: TSourceVariable): TExecutorVariable;
+  end;
+
+  TExecutorRepeat = class
+    RepeatCommand: TCommandRepeat;
+    Terminated: Boolean;
+  end;
+
+  { TExecutorRepeats }
+
+  TExecutorRepeats = class(TObjectList)
+    function Search(RepeatCommand: TCommandRepeat): TExecutorRepeat;
   end;
 
@@ -31 +42 @@
     FOnOutput: TOutputEvent;
     Variables: TExecutorVariables;
+    RepeatBlocks: TExecutorRepeats;
+    SkipNext: Boolean;
     procedure ExecuteBeginEnd(BeginEnd: TCommandBeginEnd);
+    procedure ExecuteCommand(Command: TSourceCommand);
+    procedure ExecuteBreak(CommandBreak: TCommandBreak);
+    procedure ExecuteRepeat(CommandRepeat: TCommandRepeat);
+    function ReadValueReference(Reference: TSourceReference): TSourceValue;
+    function ReadVarReference(Reference: TSourceReference): TSourceVariable;
   public
     constructor Create;
@@ -43 +61 @@
 implementation
 
+{ TExecutorRepeat }
+
+function TExecutorRepeats.Search(RepeatCommand: TCommandRepeat): TExecutorRepeat;
+var
+  Item: TExecutorRepeat;
+begin
+  Result := nil;
+  for Item in Self do
+  if Item.RepeatCommand = RepeatCommand then begin
+    Result := Item;
+    Break;
+  end;
+end;
+
 { TExecutorVariable }
 
@@ -71 +103 @@
 begin
   Variables := TExecutorVariables.Create;
+  RepeatBlocks := TExecutorRepeats.Create;
 end;
 
 destructor TSourceExecutor.Destroy;
 begin
+  RepeatBlocks.Free;
   Variables.Free;
   inherited Destroy;
@@ -81 +115 @@
 procedure TSourceExecutor.Execute(SourceCode: TSourceCode);
 begin
+  SkipNext := False;
   ExecuteBeginEnd(SourceCode.Main);
 end;
 
+function TSourceExecutor.ReadValueReference(Reference: TSourceReference): TSourceValue;
+begin
+  Result := nil;
+  if Reference is TSourceReferenceConstant then begin
+    Result := TSourceReferenceConstant(Reference).Constant.Value;
+  end else
+  if Reference is TSourceReferenceVariable then begin
+    Result := Variables.Search(TSourceReferenceVariable(Reference).Variable).Value;
+  end else raise Exception.Create('Unsupported reference');
+end;
+
+function TSourceExecutor.ReadVarReference(Reference: TSourceReference): TSourceVariable;
+begin
+  Result := nil;
+  if Reference is TSourceReferenceVariable then begin
+    Result := TSourceReferenceVariable(Reference).Variable;
+  end else raise Exception.Create('Unsupported reference');
+end;
+
 procedure TSourceExecutor.ExecuteBeginEnd(BeginEnd: TCommandBeginEnd);
 var
   IP: Integer;
-  Instruction: TSourceCommand;
+begin
+  IP := 0;
+  while IP < BeginEnd.Commands.Count do begin
+    if SkipNext then begin
+      SkipNext := False;
+      Inc(IP);
+      Continue;
+    end;
+    ExecuteCommand(TSourceCommand(BeginEnd.Commands[IP]));
+    Inc(IP);
+  end;
+end;
+
+procedure TSourceExecutor.ExecuteBreak(CommandBreak: TCommandBreak);
+var
+  RepeatBlock: TSourceCommand;
+  ExecutorRepeat: TExecutorRepeat;
+begin
+  RepeatBlock := CommandBreak.Parent;
+  while not (RepeatBlock is TCommandRepeat) and (RepeatBlock <> nil) do
+    RepeatBlock := RepeatBlock.Parent;
+  if Assigned(RepeatBlock) then begin
+    ExecutorRepeat := RepeatBlocks.Search(RepeatBlock as TCommandRepeat);
+    if Assigned(ExecutorRepeat) then begin
+      ExecutorRepeat.Terminated := True;
+    end else
+    raise Exception.Create('Missing executor repeat block');
+  end else
+  raise Exception.Create('Used break outside repeat loop');
+end;
+
+procedure TSourceExecutor.ExecuteRepeat(CommandRepeat: TCommandRepeat);
+var
+  RepeatBlock: TExecutorRepeat;
+begin
+  RepeatBlock := TExecutorRepeat.Create;
+  RepeatBlock.RepeatCommand := CommandRepeat;
+  RepeatBlock.Terminated := False;
+  RepeatBlocks.Add(RepeatBlock);
+  repeat
+    ExecuteCommand(CommandRepeat.Command);
+  until RepeatBlock.Terminated;
+  RepeatBlocks.Remove(RepeatBlock);
+end;
+
+procedure TSourceExecutor.ExecuteCommand(Command: TSourceCommand);
+var
   Variable: TSourceVariable;
   Value: TSourceValue;
@@ -93 +193 @@
   Text: string;
   IntValue: Integer;
-  SkipNext: Boolean;
-
-function ReadValueReference(Reference: TSourceReference): TSourceValue;
-begin
-  Result := nil;
-  if Reference is TSourceReferenceConstant then begin
-    Result := TSourceReferenceConstant(Reference).Constant.Value;
-  end else
-  if Reference is TSourceReferenceVariable then begin
-    Result := Variables.Search(TSourceReferenceVariable(Reference).Variable).Value;
-  end else raise Exception.Create('Unsupported reference');
-end;
-
-function ReadVarReference(Reference: TSourceReference): TSourceVariable;
-begin
-  Result := nil;
-  if Reference is TSourceReferenceVariable then begin
-    Result := TSourceReferenceVariable(Reference).Variable;
-  end else raise Exception.Create('Unsupported reference');
-end;
-
-begin
-  SkipNext := False;
-  IP := 0;
-  while IP < BeginEnd.Instructions.Count do begin
-    if SkipNext then begin
-      SkipNext := False;
-      Inc(IP);
-      Continue;
-    end;
-    Instruction := TSourceCommand(BeginEnd.Instructions[IP]);
-    if Instruction is TCommandFunctionCall then
-    with TCommandFunctionCall(Instruction) do begin
-      if Name = 'print' then begin
-        if Assigned(FOnOutput) then begin
-          Value := ReadValueReference(TSourceReference(Parameters[0]));
-          if Value is TSourceValueString then
-            FOnOutput(TSourceValueString(Value).Value)
-          else if Value is TSourceValueInteger then
-            FOnOutput(IntToStr(TSourceValueInteger(Value).Value))
-          else raise Exception.Create('Unsupported value type');
-        end;
+begin
+  if Command is TCommandFunctionCall then
+  with TCommandFunctionCall(Command) do begin
+    if Name = 'print' then begin
+      if Assigned(FOnOutput) then begin
+        Value := ReadValueReference(TSourceReference(Parameters[0]));
+        if Value is TSourceValueString then
+          FOnOutput(TSourceValueString(Value).Value)
+        else if Value is TSourceValueInteger then
+          FOnOutput(IntToStr(TSourceValueInteger(Value).Value))
+        else raise Exception.Create('Unsupported value type');
+      end;
+    end else
+    if Name = 'println' then begin
+      if Assigned(FOnOutput) then begin
+        Value := ReadValueReference(TSourceReference(Parameters[0]));
+        if Value is TSourceValueString then
+          FOnOutput(TSourceValueString(Value).Value + LineEnding)
+        else if Value is TSourceValueInteger then
+          FOnOutput(IntToStr(TSourceValueInteger(Value).Value) + LineEnding)
+        else raise Exception.Create('Unsupported value type');
+      end;
+    end else
+    if Name = 'inputln' then begin
+      if Assigned(FOnInput) then begin
+        Variable := ReadVarReference(TSourceReference(Parameters[0]));
+        ExecutorVar := Variables.Search(Variable);
+        if ExecutorVar.Value is TSourceValueString then begin
+          TSourceValueString(ExecutorVar.Value).Value := FOnInput;
+          FOnOutput(TSourceValueString(ExecutorVar.Value).Value + LineEnding);
+        end else
+        if ExecutorVar.Value is TSourceValueInteger then begin
+          Text := FOnInput;
+          if TryStrToInt(Text, IntValue) then
+            TSourceValueInteger(ExecutorVar.Value).Value := IntValue
+            else TSourceValueInteger(ExecutorVar.Value).Value := 0;
+          FOnOutput(IntToStr(TSourceValueInteger(ExecutorVar.Value).Value) + LineEnding);
+        end else
+        raise Exception.Create('Unsupported value type');
+      end;
+    end else
+    if Name = 'assign' then begin
+      Variable := ReadVarReference(TSourceReference(Parameters[0]));
+      Value := ReadValueReference(TSourceReference(Parameters[1]));
+      ExecutorVar := Variables.Search(Variable);
+      if not Assigned(ExecutorVar) then begin
+        ExecutorVar := TExecutorVariable.Create;
+        ExecutorVar.Variable := Variable;
+        Variables.Add(ExecutorVar);
+        ExecutorVar.Value := Variable.ValueType.ValueClass.Create;
+      end;
+      ExecutorVar.Value.Assign(Value);
+    end else
+    if Name = 'increment' then begin
+      Variable := ReadVarReference(TSourceReference(Parameters[0]));
+      Value := ReadValueReference(TSourceReference(Parameters[1]));
+      ExecutorVar := Variables.Search(Variable);
+      if not Assigned(ExecutorVar) then raise Exception.Create('Variable not found');
+      if (ExecutorVar.Value is TSourceValueInteger) and (Value is TSourceValueInteger) then
+        Inc(TSourceValueInteger(ExecutorVar.Value).Value, TSourceValueInteger(Value).Value)
+      else raise Exception.Create('Wrong type for increment');
+    end else
+    if Name = 'decrement' then begin
+      Variable := ReadVarReference(TSourceReference(Parameters[0]));
+      Value := ReadValueReference(TSourceReference(Parameters[1]));
+      ExecutorVar := Variables.Search(Variable);
+      if not Assigned(ExecutorVar) then raise Exception.Create('Variable not found');
+      if (ExecutorVar.Value is TSourceValueInteger) and (Value is TSourceValueInteger) then
+        Dec(TSourceValueInteger(ExecutorVar.Value).Value, TSourceValueInteger(Value).Value)
+      else raise Exception.Create('Wrong type for increment');
+    end else
+    raise Exception.Create('Unsupported function: ' + TCommandFunctionCall(Command).Name);
+  end else
+  if Command is TCommandBeginEnd then begin
+    ExecuteBeginEnd(TCommandBeginEnd(Command));
+  end else
+  if Command is TCommandBreak then begin
+    ExecuteBreak(TCommandBreak(Command));
+  end else
+  if Command is TCommandIfZero then begin
+    ExecutorVar := Variables.Search(TCommandIfZero(Command).Variable.Variable);
+    if Assigned(ExecutorVar) then begin
+      if ExecutorVar.Variable.ValueType.Name = 'Integer' then begin
+        if TSourceValueInteger(ExecutorVar.Value).Value <> 0 then SkipNext := True;
       end else
-      if Name = 'println' then begin
-        if Assigned(FOnOutput) then begin
-          Value := ReadValueReference(TSourceReference(Parameters[0]));
-          if Value is TSourceValueString then
-            FOnOutput(TSourceValueString(Value).Value + LineEnding)
-          else if Value is TSourceValueInteger then
-            FOnOutput(IntToStr(TSourceValueInteger(Value).Value) + LineEnding)
-          else raise Exception.Create('Unsupported value type');
-        end;
-      end else
-      if Name = 'inputln' then begin
-        if Assigned(FOnInput) then begin
-          Variable := ReadVarReference(TSourceReference(Parameters[0]));
-          ExecutorVar := Variables.Search(Variable);
-          if ExecutorVar.Value is TSourceValueString then begin
-            TSourceValueString(ExecutorVar.Value).Value := FOnInput;
-            FOnOutput(TSourceValueString(ExecutorVar.Value).Value + LineEnding);
-          end else
-          if ExecutorVar.Value is TSourceValueInteger then begin
-            Text := FOnInput;
-            if TryStrToInt(Text, IntValue) then
-              TSourceValueInteger(ExecutorVar.Value).Value := IntValue
-              else TSourceValueInteger(ExecutorVar.Value).Value := 0;
-            FOnOutput(IntToStr(TSourceValueInteger(ExecutorVar.Value).Value) + LineEnding);
-          end else
-          raise Exception.Create('Unsupported value type');
-        end;
-      end else
-      if Name = 'assign' then begin
-        Variable := ReadVarReference(TSourceReference(Parameters[0]));
-        Value := ReadValueReference(TSourceReference(Parameters[1]));
-        ExecutorVar := Variables.Search(Variable);
-        if not Assigned(ExecutorVar) then begin
-          ExecutorVar := TExecutorVariable.Create;
-          ExecutorVar.Variable := Variable;
-          Variables.Add(ExecutorVar);
-          ExecutorVar.Value := Variable.ValueType.ValueClass.Create;
-        end;
-        ExecutorVar.Value.Assign(Value);
-      end else
-      if Name = 'increment' then begin
-        Variable := ReadVarReference(TSourceReference(Parameters[0]));
-        Value := ReadValueReference(TSourceReference(Parameters[1]));
-        ExecutorVar := Variables.Search(Variable);
-        if not Assigned(ExecutorVar) then raise Exception.Create('Variable not found');
-        if (ExecutorVar.Value is TSourceValueInteger) and (Value is TSourceValueInteger) then
-          Inc(TSourceValueInteger(ExecutorVar.Value).Value, TSourceValueInteger(Value).Value)
-        else raise Exception.Create('Wrong type for increment');
-      end else
-      raise Exception.Create('Unsupported function: ' + TCommandFunctionCall(Instruction).Name);
-    end else
-    if Instruction is TCommandBeginEnd then begin
-      ExecuteBeginEnd(TCommandBeginEnd(Instruction));
-    end else
-    if Instruction is TCommandIfZero then begin
-      ExecutorVar := Variables.Search(TCommandIfZero(Instruction).Variable);
-      if Assigned(ExecutorVar) then begin
-        if ExecutorVar.Variable.ValueType.Name = 'Integer' then begin
-          if TSourceValueInteger(ExecutorVar.Value).Value = 0 then SkipNext := True;
-        end else
-        raise Exception.Create('Can compare only integers');
-      end else
-      raise Exception.Create('Variable not found');
-    end else
-    raise Exception.Create('Unsupported instruction');
-    Inc(IP);
-  end;
+      raise Exception.Create('Can compare only integers');
+    end else
+    raise Exception.Create('Variable not found');
+  end else
+  if Command is TCommandRepeat then begin
+    ExecuteRepeat(Command as TCommandRepeat);
+  end else
+  raise Exception.Create('Unsupported instruction');
 end;
 

branches/easy compiler/USourceGenerator.pas

@@ -15 +15 @@
     Indent: Integer;
     function GenerateBeginEnd(BeginEnd: TCommandBeginEnd): string;
+    function GenerateCommand(Command: TSourceCommand): string;
+    function GenerateRef(Reference: TSourceReference): string;
     function IndentStr: string;
   public
@@ -49 +51 @@
 end;
 
-function TSourceGenerator.GenerateBeginEnd(BeginEnd: TCommandBeginEnd): string;
+function TSourceGenerator.GenerateRef(Reference: TSourceReference): string;
 var
-  Instruction: TSourceCommand;
-  I: Integer;
   Value: TSourceValue;
-
-function GenerateRef(Reference: TSourceReference): string;
 begin
   Result := '';
@@ -71 +69 @@
 end;
 
+function TSourceGenerator.GenerateCommand(Command: TSourceCommand): string;
+begin
+  Result := '';
+  if Command is TCommandFunctionCall then
+  with TCommandFunctionCall(Command) do begin
+    if Name = 'print' then begin
+      Result := Result + IndentStr + 'Write(' + GenerateRef(TSourceReference(Parameters[0])) + ');' +
+        LineEnding;
+    end else
+    if Name = 'println' then begin
+      Result := Result + IndentStr + 'WriteLn(' + GenerateRef(TSourceReference(Parameters[0])) + ');' +
+        LineEnding;
+    end else
+    if Name = 'assign' then begin
+      Result := Result + IndentStr + GenerateRef(TSourceReference(Parameters[0])) + ' := ' +
+        GenerateRef(TSourceReference(Parameters[1])) + ';' + LineEnding;
+    end else
+    if Name = 'inputln' then begin
+      Result := Result + IndentStr + 'ReadLn(' + GenerateRef(TSourceReference(Parameters[0])) + ');' + LineEnding;
+    end else
+    if Name = 'increment' then begin
+      Result := Result + IndentStr + 'Inc(' + GenerateRef(TSourceReference(Parameters[0])) + ', ' +
+        GenerateRef(TSourceReference(Parameters[1])) + ');' + LineEnding;
+    end else
+    if Name = 'decrement' then begin
+      Result := Result + IndentStr + 'Dec(' + GenerateRef(TSourceReference(Parameters[0])) + ', ' +
+        GenerateRef(TSourceReference(Parameters[1])) + ');' + LineEnding;
+    end else
+    raise Exception.Create('Unsupported instruction name.');
+  end else
+  if Command is TCommandBeginEnd then begin
+    Result := Result + GenerateBeginEnd(TCommandBeginEnd(Command)) +
+      ';' + LineEnding;
+  end else
+  if Command is TCommandBreak then begin
+    Result := Result + IndentStr + 'Break;' + LineEnding;
+  end else
+  if Command is TCommandContinue then begin
+    Result := Result + IndentStr + 'Continue;' + LineEnding;
+  end else
+  if Command is TCommandRepeat then begin
+    Result := Result + IndentStr + 'repeat' + LineEnding;
+    Inc(Indent);
+    Result := Result + IndentStr +  GenerateCommand(TCommandRepeat(Command).Command) + LineEnding;
+    Dec(Indent);
+    Result := Result + IndentStr + 'until False;' + LineEnding;
+  end else
+  if Command is TCommandIfZero then begin
+    Result := Result + IndentStr + 'if ' + TCommandIfZero(Command).Variable.Variable.Name + ' = 0 then ';
+  end else
+  raise Exception.Create('Unsupported instruction');
+end;
+
+function TSourceGenerator.GenerateBeginEnd(BeginEnd: TCommandBeginEnd): string;
+var
+  I: Integer;
 begin
   Result := '';
@@ -76 +130 @@
   Inc(Indent);
   with BeginEnd do
-  for I := 0 to Instructions.Count - 1 do begin
-    Instruction := TSourceCommand(Instructions[I]);
-    if Instruction is TCommandFunctionCall then
-    with TCommandFunctionCall(Instruction) do begin
-      if Name = 'print' then begin
-        Result := Result + IndentStr + 'Write(' + GenerateRef(TSourceReference(Parameters[0])) + ');' +
-          LineEnding;
-      end else
-      if Name = 'println' then begin
-        Result := Result + IndentStr + 'WriteLn(' + GenerateRef(TSourceReference(Parameters[0])) + ');' +
-          LineEnding;
-      end else
-      if Name = 'assign' then begin
-        Result := Result + IndentStr + GenerateRef(TSourceReference(Parameters[0])) + ' := ' +
-          GenerateRef(TSourceReference(Parameters[1])) + ';' + LineEnding;
-      end else
-      if Name = 'inputln' then begin
-        Result := Result + IndentStr + 'ReadLn(' + GenerateRef(TSourceReference(Parameters[0])) + ');' + LineEnding;
-      end else
-      if Name = 'increment' then begin
-        Result := Result + IndentStr + 'Inc(' + GenerateRef(TSourceReference(Parameters[0])) + ', ' +
-          GenerateRef(TSourceReference(Parameters[1])) + ');' + LineEnding;
-      end else
-      raise Exception.Create('Unsupported instruction name.');
-    end else
-    if Instruction is TCommandBeginEnd then begin
-      Result := Result + GenerateBeginEnd(TCommandBeginEnd(Instruction)) +
-        ';' + LineEnding;
-    end else
-    if Instruction is TCommandIfZero then begin
-      Result := Result + IndentStr + 'if ' + TCommandIfZero(Instruction).Variable.Name + ' = 0 then ';
-    end else
-    raise Exception.Create('Unsupported instruction');
+  for I := 0 to Commands.Count - 1 do begin
+    Result := Result + GenerateCommand(TSourceCommand(Commands[I]));
   end;
   Dec(Indent);