Changeset 222 for branches/interpreter2

Timestamp:

Nov 25, 2020, 12:18:45 AM (4 years ago)

Author:

chronos

Message:

• Added: Support for more expression operators.
• Added: Support for brackets in expressions.

Location:

branches/interpreter2

Files:

• Forms/UFormMain.lfm (modified) (2 diffs)
• Forms/UFormMain.pas (modified) (9 diffs)
• Generators/UGeneratorCSharp.pas (modified) (7 diffs)
• Generators/UGeneratorPascal.pas (modified) (5 diffs)
• Generators/UGeneratorPhp.pas (modified) (6 diffs)
• Generators/UGeneratorXml.pas (modified) (2 diffs)
• Parsers/UParserPascal.pas (modified) (21 diffs)
• Test.pas (modified) (2 diffs)
• UExecutor.pas (modified) (11 diffs)
• UGenerator.pas (modified) (3 diffs)
• UParser.pas (modified) (5 diffs)
• USource.pas (modified) (6 diffs)
• UTokenizer.pas (modified) (5 diffs)

branches/interpreter2/Forms/UFormMain.lfm

@@ -48 +48 @@
   end
   object MainMenu1: TMainMenu
-    Left = 790
-    Top = 753
+    Left = 760
+    Top = 760
     object MenuItemFile: TMenuItem
       Caption = 'File'
@@ -99 +99 @@
       Caption = 'Run'
       OnExecute = ARunExecute
+      ShortCut = 120
     end
     object ACompile: TAction
       Caption = 'Compile'
       OnExecute = ACompileExecute
+      ShortCut = 16497
     end
     object AExit: TAction

branches/interpreter2/Forms/UFormMain.pas

@@ -7 +7 @@
 uses
   Classes, SysUtils, Forms, Controls, Graphics, Dialogs, StdCtrls, Menus,
-  ActnList, ExtCtrls, SynHighlighterPas, SynEdit, USource, UOptimizer;
+  ActnList, ExtCtrls, SynHighlighterPas, SynEdit, USource, UOptimizer,
+  UGenerator;
 
 type
@@ -52 +53 @@
     Prog: TProgram;
     Initialized: Boolean;
+    procedure Generate(GeneratorClass: TGeneratorClass);
     procedure ExecutorOutput(Text: string);
     procedure InterpreterError(Pos: TPoint; Text: string);
@@ -90 +92 @@
 procedure TFormMain.FormDestroy(Sender: TObject);
 begin
-  if Assigned(Prog) then Prog.Free;
+  if Assigned(Prog) then FreeAndNil(Prog);
 end;
 
@@ -99 +101 @@
   DockForm(FormOutput, PanelOutput);
   UpdateInterface;
+end;
+
+procedure TFormMain.Generate(GeneratorClass: TGeneratorClass);
+var
+  Generator: TGenerator;
+  TargetFileName: string;
+begin
+  Generator := GeneratorClass.Create;
+  try
+    Generator.Prog := Prog;
+    Generator.Generate;
+    FormOutput.SetText(Generator.Output);
+    TargetFileName := 'Generated' + DirectorySeparator +
+      Generator.Name + DirectorySeparator + 'Test' + Generator.FileExt;
+    ForceDirectories(ExtractFileDir(TargetFileName));
+    FormOutput.SynEditOutput.Lines.SaveToFile(TargetFileName);
+  finally
+    Generator.Free;
+  end;
 end;
 
@@ -122 +143 @@
 
 procedure TFormMain.AGenerateCSharpExecute(Sender: TObject);
-var
-  Generator: TGeneratorCSharp;
 begin
   ACompile.Execute;
@@ -130 +149 @@
   FormOutput.Clear;
   if Assigned(Prog) then begin
-    Generator := TGeneratorCSharp.Create;
-    Generator.Prog := Prog;
-    Generator.Generate;
-    FormOutput.SetText(Generator.Output);
-    Generator.Free;
-    FormOutput.SynEditOutput.Lines.SaveToFile('Generated' + DirectorySeparator + 'Test.cs');
+    Generate(TGeneratorCSharp);
   end;
 end;
 
 procedure TFormMain.AGeneratePascalExecute(Sender: TObject);
-var
-  Generator: TGeneratorPascal;
 begin
   ACompile.Execute;
@@ -147 +159 @@
   FormOutput.SynEditOutput.Lines.Clear;
   if Assigned(Prog) then begin
-    Generator := TGeneratorPascal.Create;
-    Generator.Prog := Prog;
-    Generator.Generate;
-    FormOutput.SynEditOutput.Lines.Text := Generator.Output;
-    Generator.Free;
-    FormOutput.SynEditOutput.Lines.SaveToFile('Generated' + DirectorySeparator + 'Test.pas');
+    Generate(TGeneratorPascal);
   end;
 end;
 
 procedure TFormMain.AGeneratePhpExecute(Sender: TObject);
-var
-  Generator: TGeneratorPhp;
 begin
   ACompile.Execute;
@@ -165 +170 @@
   FormOutput.SynEditOutput.Lines.Clear;
   if Assigned(Prog) then begin
-    Generator := TGeneratorPhp.Create;
-    Generator.Prog := Prog;
-    Generator.Generate;
-    FormOutput.SynEditOutput.Lines.Text := Generator.Output;
-    Generator.Free;
-    FormOutput.SynEditOutput.Lines.SaveToFile('Generated' + DirectorySeparator + 'Test.php');
+    Generate(TGeneratorPhp);
   end;
 end;
 
 procedure TFormMain.AGenerateXmlExecute(Sender: TObject);
-var
-  Generator: TGeneratorXml;
 begin
   ACompile.Execute;
@@ -182 +180 @@
   FormOutput.SynEditOutput.Lines.Clear;
   if Assigned(Prog) then begin
-    Generator := TGeneratorXml.Create;
-    Generator.Prog := Prog;
-    Generator.Generate;
-    FormOutput.SynEditOutput.Lines.Text := Generator.Output;
-    Generator.Free;
-    FormOutput.SynEditOutput.Lines.SaveToFile('Generated' + DirectorySeparator + 'Test.xml');
+    Generate(TGeneratorXml);
   end;
 end;

branches/interpreter2/Generators/UGeneratorCSharp.pas

@@ -31 +31 @@
     procedure GenerateExpressionOperation(Block: TBlock; Expression: TExpressionOperation);
     procedure GenerateExpressionOperand(Block: TBlock; Expression: TExpressionOperand);
+    procedure GenerateExpressionBrackets(Block: TBlock; Expression: TExpressionBrackets);
     procedure GenerateBreak(Block: TBlock; BreakCmd: TBreak);
     procedure GenerateContinue(Block: TBlock; ContinueCmd: TContinue);
@@ -37 +38 @@
     procedure GenerateValue(Value: TValue);
   public
-    Prog: TProgram;
     procedure Generate; override;
-  end;
+    constructor Create; override;
+  end;
+
 
 implementation
+
+const
+  ExpressionOperatorTextCSharp: array[TExpressionOperator] of string = ('', '+',
+    '-', '*', '/', '/', '%', '&', '^', '|', '<<',
+    '>>', '==', '!=', '<', '>', '<=','>=', '!');
 
 { TGeneratorCSharp }
@@ -144 +151 @@
   if Expression is TExpressionOperand then
     GenerateExpressionOperand(Block, TExpressionOperand(Expression))
+  else
+  if Expression is TExpressionBrackets then
+    GenerateExpressionBrackets(Block, TExpressionBrackets(Expression))
   else raise Exception.Create('Unknown expression class.');
 end;
@@ -154 +164 @@
   for I := 0 to Expression.Items.Count - 1 do begin
     if I > 0 then begin
-      if Expression.Operation = eoAdd then AddText(' + ')
-      else if Expression.Operation = eoSub then AddText(' - ')
-      else if Expression.Operation = eoEqual then AddText(' == ')
-      else if Expression.Operation = eoNotEqual then AddText(' != ');
+      AddText(' ' + ExpressionOperatorTextCSharp[Expression.Operation] + ' ');
     end;
     GenerateExpression(Block, TExpression(Expression.Items[I]));
@@ -173 +180 @@
     else raise Exception.Create('Unsupported exception operand type.');
   end;
+end;
+
+procedure TGeneratorCSharp.GenerateExpressionBrackets(Block: TBlock;
+  Expression: TExpressionBrackets);
+begin
+  AddText('(');
+  GenerateExpression(Block, Expression.Expression);
+  AddText(')');
 end;
 
@@ -233 +248 @@
 
 procedure TGeneratorCSharp.GenerateBlock(ParentBlock: TBlock; Block: TBlock);
-var
-  I: Integer;
 begin
   if Block.BeginEnd.Commands.Count > 0 then begin
@@ -353 +366 @@
 end;
 
+constructor TGeneratorCSharp.Create;
+begin
+  inherited;
+  Name := 'CSharp';
+  FileExt := '.cs';
+end;
+
 end.
 

branches/interpreter2/Generators/UGeneratorPascal.pas

@@ -31 +31 @@
     procedure GenerateExpressionOperation(Block: TBlock; Expression: TExpressionOperation);
     procedure GenerateExpressionOperand(Block: TBlock; Expression: TExpressionOperand);
+    procedure GenerateExpressionBrackets(Block: TBlock; Expression: TExpressionBrackets);
     procedure GenerateBreak(Block: TBlock; BreakCmd: TBreak);
     procedure GenerateContinue(Block: TBlock; ContinueCmd: TContinue);
     procedure GenerateValue(Value: TValue);
   public
-    Prog: TProgram;
     procedure Generate; override;
+    constructor Create; override;
   end;
 
@@ -134 +135 @@
   if Expression is TExpressionOperand then
     GenerateExpressionOperand(Block, TExpressionOperand(Expression))
+  else
+  if Expression is TExpressionBrackets then
+    GenerateExpressionBrackets(Block, TExpressionBrackets(Expression))
   else raise Exception.Create('Unknown expression class.');
 end;
@@ -145 +149 @@
     if I > 0 then begin
       AddText(' ');
-      if Expression.Operation = eoAdd then AddText('+')
-      else if Expression.Operation = eoSub then AddText('-')
-      else if Expression.Operation = eoEqual then AddText('=')
-      else if Expression.Operation = eoNotEqual then AddText('<>');
+      AddText(ExpressionOperatorText[Expression.Operation]);
       AddText(' ');
     end;
@@ -165 +166 @@
     else raise Exception.Create('Unsupported exception operand type.');
   end;
+end;
+
+procedure TGeneratorPascal.GenerateExpressionBrackets(Block: TBlock;
+  Expression: TExpressionBrackets);
+begin
+  AddText('(');
+  GenerateExpression(Block, Expression.Expression);
+  AddText(')');
 end;
 
@@ -313 +322 @@
 end;
 
+constructor TGeneratorPascal.Create;
+begin
+  inherited;
+  Name := 'Pascal';
+  FileExt := '.pas';
+end;
+
 end.
 

branches/interpreter2/Generators/UGeneratorPhp.pas

@@ -30 +30 @@
     procedure GenerateExpressionOperation(Block: TBlock; Expression: TExpressionOperation);
     procedure GenerateExpressionOperand(Block: TBlock; Expression: TExpressionOperand);
+    procedure GenerateExpressionBrackets(Block: TBlock; Expression: TExpressionBrackets);
     procedure GenerateBreak(Block: TBlock; BreakCmd: TBreak);
     procedure GenerateReturn(Block: TBlock; Return: TReturn);
@@ -35 +36 @@
     procedure GenerateValue(Value: TValue);
   public
-    Prog: TProgram;
     procedure Generate; override;
-  end;
+    constructor Create; override;
+  end;
+
 
 implementation
+
+const
+  ExpressionOperatorTextPhp: array[TExpressionOperator] of string = ('', '+',
+    '-', '*', '/', '/', '%', 'and', 'xor', 'or', '<<',
+    '>>', '==', '!=', '<', '>', '<=','>=', '!');
 
 { TGeneratorPhp }
@@ -142 +149 @@
   if Expression is TExpressionOperand then
     GenerateExpressionOperand(Block, TExpressionOperand(Expression))
+  else
+  if Expression is TExpressionBrackets then
+    GenerateExpressionBrackets(Block, TExpressionBrackets(Expression))
   else raise Exception.Create('Unknown expression class.');
 end;
@@ -156 +166 @@
         else AddText(' + ');
       end
-      else if Expression.Operation = eoSub then AddText(' - ')
-      else if Expression.Operation = eoEqual then AddText(' == ')
-      else if Expression.Operation = eoNotEqual then AddText(' != ');
+      else AddText(' ' + ExpressionOperatorTextPhp[Expression.Operation] + ' ');
     end;
     GenerateExpression(Block, TExpression(Expression.Items[I]));
@@ -174 +182 @@
     else raise Exception.Create('Unsupported exception operand type.');
   end;
+end;
+
+procedure TGeneratorPhp.GenerateExpressionBrackets(Block: TBlock;
+  Expression: TExpressionBrackets);
+begin
+  AddText('(');
+  GenerateExpression(Block, Expression.Expression);
+  AddText(')');
 end;
 
@@ -290 +306 @@
 end;
 
+constructor TGeneratorPhp.Create;
+begin
+  inherited;
+  Name := 'PHP';
+  FileExt := '.php';
+end;
+
 end.
 

branches/interpreter2/Generators/UGeneratorXml.pas

@@ -16 +16 @@
     procedure GenerateNode(SourceNode: TSourceNode);
   public
-    Prog: TProgram;
     procedure Generate; override;
+    constructor Create; override;
   end;
 
@@ -73 +73 @@
 end;
 
+constructor TGeneratorXml.Create;
+begin
+  inherited;
+  Name := 'XML';
+  FileExt := '.xml';
+end;
+
 end.
 

branches/interpreter2/Parsers/UParserPascal.pas

@@ -9 +9 @@
 
 type
+
+  { TParserPascal }
+
   TParserPascal = class(TParser)
   protected
@@ -21 +24 @@
     function ParseFunctionParameter(Block: TBlock; out Parameter: TFunctionParameter): Boolean;
     function ParseAssignment(Block: TBlock; out Assignment: TAssignment): Boolean;
-    function ParseExpression(Block: TBlock; out Expression: TExpression): Boolean;
+    function ParseExpression(Block: TBlock; out Expression: TExpression;
+      WithOperation: Boolean = True): Boolean;
     function ParseExpressionOperation(Block: TBlock; out ExpressionOperation: TExpressionOperation): Boolean;
     function ParseExpressionOperand(Block: TBlock; out ExpressionOperand: TExpressionOperand): Boolean;
+    function ParseExpressionBrackets(Block: TBlock; out ExpressionBrackets: TExpressionBrackets): Boolean;
     function ParseConstantRef(Block: TBlock; out ConstantRef: TConstant): Boolean;
     function ParseConstant(Block: TBlock; out ConstantRef: TConstant): Boolean;
@@ -42 +47 @@
   Command: TCommand;
 begin
-  if Tokenizer.CheckNext('begin', tkKeyword) then begin
-    Tokenizer.Expect('begin', tkKeyword);
+  if Tokenizer.CheckNextAndRead('begin', tkKeyword) then begin
     BeginEnd := TBeginEnd.Create;
     Result := True;
@@ -77 +81 @@
       FunctionCall := TFunctionCall.Create;
       FunctionCall.FunctionDef := FunctionDef;
-      if Tokenizer.CheckNext('(', tkSpecialSymbol) then begin
-        Tokenizer.Expect('(', tkSpecialSymbol);
+      if Tokenizer.CheckNextAndRead('(', tkSpecialSymbol) then begin
         for I := 0 to FunctionDef.Params.Count - 1 do begin
           if I > 0 then Tokenizer.Expect(',', tkSpecialSymbol);
@@ -160 +163 @@
   Prog.SystemBlock.Free;
   Prog.SystemBlock := SystemBlock;
-  if Tokenizer.CheckNext('program', tkKeyword) then begin
-    Tokenizer.Expect('program', tkKeyword);
+  if Tokenizer.CheckNextAndRead('program', tkKeyword) then begin
     Token := Tokenizer.GetNext;
     if Token.Kind = tkIdentifier then
@@ -216 +218 @@
   TypeRef: TType;
 begin
-  if Tokenizer.CheckNext('var', tkKeyword) then begin
-    Result := True;
-    Tokenizer.Expect('var', tkKeyword);
+  if Tokenizer.CheckNextAndRead('var', tkKeyword) then begin
+    Result := True;
     while Tokenizer.CheckNextKind(tkIdentifier) do begin
       Token := Tokenizer.GetNext;
@@ -251 +252 @@
   TypeRef: TType;
 begin
-  if Tokenizer.CheckNext('const', tkKeyword) then begin
-    Result := True;
-    Tokenizer.Expect('const', tkKeyword);
+  if Tokenizer.CheckNextAndRead('const', tkKeyword) then begin
+    Result := True;
     while Tokenizer.CheckNextKind(tkIdentifier) do begin
       Token := Tokenizer.GetNext;
@@ -300 +300 @@
 begin
   Result := False;
-  if Tokenizer.CheckNext('function', tkKeyword) then begin
-    Tokenizer.Expect('function', tkKeyword);
+  if Tokenizer.CheckNextAndRead('function', tkKeyword) then begin
     Result := True;
     Func := TFunction.Create;
@@ -307 +306 @@
     if Token.Kind = tkIdentifier then begin
       Func.Name := Token.Text;
-      if Tokenizer.CheckNext('(', tkSpecialSymbol) then begin
-        Tokenizer.Expect('(', tkSpecialSymbol);
+      if Tokenizer.CheckNextAndRead('(', tkSpecialSymbol) then begin
         while not Tokenizer.CheckNext(')', tkSpecialSymbol) do begin
           if Func.Params.Count > 0 then Tokenizer.Expect(',', tkSpecialSymbol);
@@ -324 +322 @@
         end;
       end;
-      if Tokenizer.CheckNext(':', tkSpecialSymbol) then begin
-        Tokenizer.Expect(':', tkSpecialSymbol);
+      if Tokenizer.CheckNextAndRead(':', tkSpecialSymbol) then begin
         Token := Tokenizer.GetNext;
         if Token.Kind = tkIdentifier then begin
@@ -402 +399 @@
 end;
 
-function TParserPascal.ParseExpression(Block: TBlock; out Expression: TExpression
-  ): Boolean;
+function TParserPascal.ParseExpression(Block: TBlock; out Expression: TExpression;
+  WithOperation: Boolean = True): Boolean;
 var
   ExpressionOperation: TExpressionOperation;
   ExpressionOperand: TExpressionOperand;
-begin
-  Result := False;
-  if ParseExpressionOperation(Block, ExpressionOperation) then begin
+  ExpressionBrackets: TExpressionBrackets;
+begin
+  Result := False;
+  if WithOperation and ParseExpressionOperation(Block, ExpressionOperation) then begin
     Result := True;
     Expression := ExpressionOperation;
+  end else
+  if ParseExpressionBrackets(Block, ExpressionBrackets) then begin
+    Result := True;
+    Expression := ExpressionBrackets;
   end else
   if ParseExpressionOperand(Block, ExpressionOperand) then begin
@@ -422 +424 @@
   ExpressionOperation: TExpressionOperation): Boolean;
 var
-  Operand: TExpressionOperand;
-  Token: TToken;
   Expression: TExpression;
+  Token: TToken;
   LastPos: TTokenizerPos;
   I: Integer;
@@ -431 +432 @@
   Result := False;
   LastPos := Tokenizer.Pos;
-  if ParseExpressionOperand(Block, Operand) then begin
+  if ParseExpression(Block, Expression, False) then begin
     Token := Tokenizer.GetNext;
-    if (Token.Kind = tkSpecialSymbol) and Tokenizer.IsOperator(Token.Text) then begin
+    if Tokenizer.IsOperator(Token.Text) then begin
       Result := True;
       ExpressionOperation := TExpressionOperation.Create;
-      ExpressionOperation.TypeRef := Operand.GetType;
-      if Token.Text = '+' then ExpressionOperation.Operation := eoAdd
-      else if Token.Text = '-' then ExpressionOperation.Operation := eoSub
-      else if Token.Text = '=' then ExpressionOperation.Operation := eoEqual
-      else if Token.Text = '<>' then ExpressionOperation.Operation := eoNotEqual
-      else Error('Unsupported operator ' + Token.Text);
+      ExpressionOperation.Items.Add(Expression);
+      ExpressionOperation.TypeRef := Expression.GetType;
+      ExpressionOperation.Operation := GetOperatorByName(Token.Text);
+      if ExpressionOperation.Operation = eoNone then
+        Error('Unsupported operator ' + Token.Text);
       ExpressionOperation.FunctionRef := ExpressionOperation.TypeRef.Functions.SearchByName(ExpressionOperation.GetFunctionName);
-      if not Assigned(ExpressionOperation.FunctionRef.ResultType) then
-        raise Exception.Create('Missing result type for function');
-      ExpressionOperation.TypeRef := ExpressionOperation.FunctionRef.ResultType;
-      ExpressionOperation.Items.Add(Operand);
-      I := 1;
-      if ParseExpression(Block, Expression) then begin
-        ExpectedType := TFunctionParameter(ExpressionOperation.FunctionRef.Params[I]).TypeRef;
-        if Expression.GetType = ExpectedType then
-          ExpressionOperation.Items.Add(Expression)
-          else Error('Expression operands needs to be same type. Expected ' + ExpectedType.Name + ' but found ' + Expression.GetType.Name);
-      end else Error('Missing operand.');
-    end else Operand.Free;
+      if Assigned(ExpressionOperation.FunctionRef) then begin
+        if not Assigned(ExpressionOperation.FunctionRef.ResultType) then
+          raise Exception.Create('Missing result type for function');
+        ExpressionOperation.TypeRef := ExpressionOperation.FunctionRef.ResultType;
+        I := 1;
+        if ParseExpression(Block, Expression) then begin
+          ExpectedType := TFunctionParameter(ExpressionOperation.FunctionRef.Params[I]).TypeRef;
+          if Expression.GetType = ExpectedType then
+            ExpressionOperation.Items.Add(Expression)
+            else Error('Expression operands needs to be same type. Expected ' + ExpectedType.Name + ' but found ' + Expression.GetType.Name);
+        end else Error('Missing operand.');
+      end else Error('Operator ' + Token.Text + ' not defind for type ' + ExpressionOperation.TypeRef.Name + '.');
+    end else Expression.Free;
   end;
   if not Result then Tokenizer.Pos := LastPos;
@@ -490 +491 @@
     ExpressionOperand.VariableRef := Variable;
     ExpressionOperand.OperandType := otVariableRef;
-  end else Error('Expected expression operand.');
+  end else
+    Error('Expected expression operand.');
+end;
+
+function TParserPascal.ParseExpressionBrackets(Block: TBlock; out
+  ExpressionBrackets: TExpressionBrackets): Boolean;
+var
+  Expression: TExpression;
+begin
+  Result := False;
+  if Tokenizer.CheckNextAndRead('(', tkSpecialSymbol) then begin
+    Result := True;
+    if ParseExpression(Block, Expression) then begin
+      ExpressionBrackets := TExpressionBrackets.Create;
+      ExpressionBrackets.Expression := Expression;
+    end;
+    Tokenizer.Expect(')', tkSpecialSymbol);
+  end;
 end;
 
@@ -562 +580 @@
 begin
   Result := False;
-  if Tokenizer.CheckNext('if', tkKeyword) then begin
-    Tokenizer.Expect('if', tkKeyword);
+  if Tokenizer.CheckNextAndRead('if', tkKeyword) then begin
     Result := True;
     IfThenElse := TIfThenElse.Create;
@@ -574 +591 @@
         IfThenElse.CommandThen := Command;
         Command.Parent := IfThenElse;
-        if Tokenizer.CheckNext('else', tkKeyword) then begin
-          Tokenizer.Expect('else', tkKeyword);
+        if Tokenizer.CheckNextAndRead('else', tkKeyword) then begin
           if ParseCommand(Block, Command) then begin
             IfThenElse.CommandElse.Free;
@@ -593 +609 @@
 begin
   Result := False;
-  if Tokenizer.CheckNext('while', tkKeyword) then begin
-    Tokenizer.Expect('while', tkKeyword);
+  if Tokenizer.CheckNextAndRead('while', tkKeyword) then begin
     Result := True;
     WhileDo := TWhileDo.Create;
@@ -617 +632 @@
 begin
   Result := False;
-  if Tokenizer.CheckNext('repeat', tkKeyword) then begin
-    Tokenizer.Expect('repeat', tkKeyword);
+  if Tokenizer.CheckNextAndRead('repeat', tkKeyword) then begin
     RepeatUntil := TRepeatUntil.Create;
     Result := True;
@@ -647 +661 @@
 begin
   Result := False;
-  if Tokenizer.CheckNext('for', tkKeyword) then begin
-    Tokenizer.Expect('for', tkKeyword);
+  if Tokenizer.CheckNextAndRead('for', tkKeyword) then begin
     Result := True;
     ForToDo := TForToDo.Create;
@@ -676 +689 @@
 begin
   Result := False;
-  if Tokenizer.CheckNext('break', tkKeyword) then begin
-    Tokenizer.Expect('break', tkKeyword);
+  if Tokenizer.CheckNextAndRead('break', tkKeyword) then begin
     Result := True;
     BreakCmd := TBreak.Create;
@@ -687 +699 @@
 begin
   Result := False;
-  if Tokenizer.CheckNext('continue', tkKeyword) then begin
-    Tokenizer.Expect('continue', tkKeyword);
+  if Tokenizer.CheckNextAndRead('continue', tkKeyword) then begin
     Result := True;
     ContinueCmd := TContinue.Create;

branches/interpreter2/Test.pas

@@ -15 +15 @@
 
 begin  
+  WriteLn('10 * 3 = ' + IntToStr((1 + 2) * (3 + 4)));
+
   X := 'A' + 'B';
   WriteLn(X);
@@ -20 +22 @@
   B := IntToStr(C);
   A := B;
-  
+
   // If-Then-Else
   if A = '2' then begin

branches/interpreter2/UExecutor.pas

@@ -92 +92 @@
     function ExecuteStrToInt(Params: array of TValue): TValue;
     function ExecuteBooleanAssign(Params: array of TValue): TValue;
+    function ExecuteBooleanNot(Params: array of TValue): TValue;
     function ExecuteBooleanEqual(Params: array of TValue): TValue;
     function ExecuteBooleanNotEqual(Params: array of TValue): TValue;
@@ -101 +102 @@
     function ExecuteIntegerAdd(Params: array of TValue): TValue;
     function ExecuteIntegerSub(Params: array of TValue): TValue;
+    function ExecuteIntegerMul(Params: array of TValue): TValue;
+    function ExecuteIntegerIntDiv(Params: array of TValue): TValue;
+    function ExecuteIntegerMod(Params: array of TValue): TValue;
     function ExecuteIntegerEqual(Params: array of TValue): TValue;
     function ExecuteIntegerNotEqual(Params: array of TValue): TValue;
+    function ExecuteIntegerLesser(Params: array of TValue): TValue;
+    function ExecuteIntegerHigher(Params: array of TValue): TValue;
+    function ExecuteIntegerLesserOrEqual(Params: array of TValue): TValue;
+    function ExecuteIntegerHigherOrEqual(Params: array of TValue): TValue;
+    function ExecuteIntegerAnd(Params: array of TValue): TValue;
+    function ExecuteIntegerOr(Params: array of TValue): TValue;
+    function ExecuteIntegerXor(Params: array of TValue): TValue;
+    function ExecuteIntegerShr(Params: array of TValue): TValue;
+    function ExecuteIntegerShl(Params: array of TValue): TValue;
     procedure InitExecutorBlock(ExecutorBlock: TExecutorBlock; Block: TBlock);
   public
@@ -121 +134 @@
     function ExecuteExpressionOperation(Block: TExecutorBlock; Expression: TExpressionOperation): TValue;
     function ExecuteExpressionOperand(Block: TExecutorBlock; Expression: TExpressionOperand): TValue;
+    function ExecuteExpressionBrackets(Block: TExecutorBlock; Expression: TExpressionBrackets): TValue;
     procedure Run;
     procedure Output(Text: string);
@@ -323 +337 @@
 end;
 
+function TExecutor.ExecuteBooleanNot(Params: array of TValue): TValue;
+begin
+  Result := TValueBoolean.Create;
+  TValueBoolean(Result).Value := not TValueBoolean(Params[0]).Value;
+end;
+
 function TExecutor.ExecuteBooleanEqual(Params: array of TValue): TValue;
 begin
@@ -377 +397 @@
 end;
 
+function TExecutor.ExecuteIntegerMul(Params: array of TValue): TValue;
+begin
+  Result := TValueInteger.Create;
+  TValueInteger(Result).Value := TValueInteger(Params[0]).Value * TValueInteger(Params[1]).Value;
+end;
+
+function TExecutor.ExecuteIntegerIntDiv(Params: array of TValue): TValue;
+begin
+  Result := TValueInteger.Create;
+  TValueInteger(Result).Value := TValueInteger(Params[0]).Value div TValueInteger(Params[1]).Value;
+end;
+
+function TExecutor.ExecuteIntegerMod(Params: array of TValue): TValue;
+begin
+  Result := TValueInteger.Create;
+  TValueInteger(Result).Value := TValueInteger(Params[0]).Value mod TValueInteger(Params[1]).Value;
+end;
+
 function TExecutor.ExecuteIntegerEqual(Params: array of TValue): TValue;
 begin
@@ -387 +425 @@
   Result := TValueBoolean.Create;
   TValueBoolean(Result).Value := TValueInteger(Params[0]).Value <> TValueInteger(Params[1]).Value;
+end;
+
+function TExecutor.ExecuteIntegerLesser(Params: array of TValue): TValue;
+begin
+  Result := TValueBoolean.Create;
+  TValueBoolean(Result).Value := TValueInteger(Params[0]).Value < TValueInteger(Params[1]).Value;
+end;
+
+function TExecutor.ExecuteIntegerHigher(Params: array of TValue): TValue;
+begin
+  Result := TValueBoolean.Create;
+  TValueBoolean(Result).Value := TValueInteger(Params[0]).Value > TValueInteger(Params[1]).Value;
+end;
+
+function TExecutor.ExecuteIntegerLesserOrEqual(Params: array of TValue): TValue;
+begin
+  Result := TValueBoolean.Create;
+  TValueBoolean(Result).Value := TValueInteger(Params[0]).Value <= TValueInteger(Params[1]).Value;
+end;
+
+function TExecutor.ExecuteIntegerHigherOrEqual(Params: array of TValue): TValue;
+begin
+  Result := TValueBoolean.Create;
+  TValueBoolean(Result).Value := TValueInteger(Params[0]).Value >= TValueInteger(Params[1]).Value;
+end;
+
+function TExecutor.ExecuteIntegerAnd(Params: array of TValue): TValue;
+begin
+  Result := TValueInteger.Create;
+  TValueInteger(Result).Value := TValueInteger(Params[0]).Value and TValueInteger(Params[1]).Value;
+end;
+
+function TExecutor.ExecuteIntegerOr(Params: array of TValue): TValue;
+begin
+  Result := TValueInteger.Create;
+  TValueInteger(Result).Value := TValueInteger(Params[0]).Value or TValueInteger(Params[1]).Value;
+end;
+
+function TExecutor.ExecuteIntegerXor(Params: array of TValue): TValue;
+begin
+  Result := TValueInteger.Create;
+  TValueInteger(Result).Value := TValueInteger(Params[0]).Value xor TValueInteger(Params[1]).Value;
+end;
+
+function TExecutor.ExecuteIntegerShr(Params: array of TValue): TValue;
+begin
+  Result := TValueInteger.Create;
+  TValueInteger(Result).Value := TValueInteger(Params[0]).Value shr TValueInteger(Params[1]).Value;
+end;
+
+function TExecutor.ExecuteIntegerShl(Params: array of TValue): TValue;
+begin
+  Result := TValueInteger.Create;
+  TValueInteger(Result).Value := TValueInteger(Params[0]).Value shl TValueInteger(Params[1]).Value;
 end;
 
@@ -410 +502 @@
           ExecutorFunction.Callback := ExecuteBooleanNotEqual;
         end;
+        if ExecutorFunction.FunctionDef.Name = '_Not' then begin
+          ExecutorFunction.Callback := ExecuteBooleanNot;
+        end else
       end else
       if ExecutorType.TypeRef.Name = 'string' then begin
@@ -435 +530 @@
           ExecutorFunction.Callback := ExecuteIntegerSub;
         end else
+        if ExecutorFunction.FunctionDef.Name = '_Mul' then begin
+          ExecutorFunction.Callback := ExecuteIntegerMul;
+        end else
+        if ExecutorFunction.FunctionDef.Name = '_IntDiv' then begin
+          ExecutorFunction.Callback := ExecuteIntegerIntDiv;
+        end else
+        if ExecutorFunction.FunctionDef.Name = '_IntMod' then begin
+          ExecutorFunction.Callback := ExecuteIntegerMod;
+        end else
         if ExecutorFunction.FunctionDef.Name = '_Equal' then begin
           ExecutorFunction.Callback := ExecuteIntegerEqual;
@@ -440 +544 @@
         if ExecutorFunction.FunctionDef.Name = '_NotEqual' then begin
           ExecutorFunction.Callback := ExecuteIntegerNotEqual;
+        end;
+        if ExecutorFunction.FunctionDef.Name = '_Lesser' then begin
+          ExecutorFunction.Callback := ExecuteIntegerLesser;
+        end else
+        if ExecutorFunction.FunctionDef.Name = '_Higher' then begin
+          ExecutorFunction.Callback := ExecuteIntegerHigher;
+        end;
+        if ExecutorFunction.FunctionDef.Name = '_LesserOrEqual' then begin
+          ExecutorFunction.Callback := ExecuteIntegerLesserOrEqual;
+        end else
+        if ExecutorFunction.FunctionDef.Name = '_HigherOrEqual' then begin
+          ExecutorFunction.Callback := ExecuteIntegerHigherOrEqual;
+        end;
+        if ExecutorFunction.FunctionDef.Name = '_And' then begin
+          ExecutorFunction.Callback := ExecuteIntegerAnd;
+        end;
+        if ExecutorFunction.FunctionDef.Name = '_Or' then begin
+          ExecutorFunction.Callback := ExecuteIntegerOr;
+        end;
+        if ExecutorFunction.FunctionDef.Name = '_Xor' then begin
+          ExecutorFunction.Callback := ExecuteIntegerXor;
+        end;
+        if ExecutorFunction.FunctionDef.Name = '_Shr' then begin
+          ExecutorFunction.Callback := ExecuteIntegerShr;
+        end;
+        if ExecutorFunction.FunctionDef.Name = '_Shl' then begin
+          ExecutorFunction.Callback := ExecuteIntegerShl;
         end;
       end;
@@ -692 +823 @@
   if Expression is TExpressionOperand then
     Result := ExecuteExpressionOperand(Block, TExpressionOperand(Expression))
-  else raise Exception.Create('Unknown expression class.');
+  else
+  if Expression is TExpressionBrackets then
+    Result := ExecuteExpressionBrackets(Block, TExpressionBrackets(Expression))
+  else
+  raise Exception.Create('Unknown expression class.');
 end;
 
@@ -733 +868 @@
 end;
 
+function TExecutor.ExecuteExpressionBrackets(Block: TExecutorBlock;
+  Expression: TExpressionBrackets): TValue;
+begin
+  Result := ExecuteExpression(Block, Expression.Expression);
+end;
+
 procedure TExecutor.Run;
 begin

branches/interpreter2/UGenerator.pas

@@ -6 +6 @@
 
 uses
-  Classes, SysUtils, strutils;
+  Classes, SysUtils, strutils, USource;
 
 type
@@ -17 +17 @@
     procedure SetIndent(AValue: Integer);
   public
+    Name: string;
+    FileExt: string;
     Output: string;
+    Prog: TProgram;
     procedure AddText(Text: string);
     procedure AddTextLine(Text: string = '');
     procedure Generate; virtual;
+    constructor Create; virtual;
+    destructor Destroy; override;
     property Indent: Integer read FIndent write SetIndent;
   end;
+
+  TGeneratorClass = class of TGenerator;
 
 
@@ -59 +66 @@
 end;
 
+constructor TGenerator.Create;
+begin
+end;
+
+destructor TGenerator.Destroy;
+begin
+  inherited;
+end;
+
 end.
 

branches/interpreter2/UParser.pas

@@ -6 +6 @@
 
 uses
-  Classes, SysUtils, Contnrs, UTokenizer, USource;
+  Classes, SysUtils, UTokenizer, USource;
 
 type
@@ -59 +59 @@
       ResultType := TypeBoolean;
     end;
+    with Functions.AddNew('_NotEqual') do begin
+      Params.AddNew('A', TypeBoolean);
+      Params.AddNew('B', TypeBoolean);
+      ResultType := TypeBoolean;
+    end;
+    with Functions.AddNew('_Not') do begin
+      Params.AddNew('A', TypeBoolean);
+      ResultType := TypeBoolean;
+    end;
   end;
   TypeString := Block.Types.AddNew('string');
@@ -100 +109 @@
       ResultType := TypeInteger;
     end;
+    with Functions.AddNew('_Mul') do begin
+      Params.AddNew('A', TypeInteger);
+      Params.AddNew('B', TypeInteger);
+      ResultType := TypeInteger;
+    end;
+    with Functions.AddNew('_IntDiv') do begin
+      Params.AddNew('A', TypeInteger);
+      Params.AddNew('B', TypeInteger);
+      ResultType := TypeInteger;
+    end;
+    with Functions.AddNew('_Mod') do begin
+      Params.AddNew('A', TypeInteger);
+      Params.AddNew('B', TypeInteger);
+      ResultType := TypeInteger;
+    end;
     with Functions.AddNew('_Equal') do begin
       Params.AddNew('A', TypeInteger);
@@ -109 +133 @@
       Params.AddNew('B', TypeInteger);
       ResultType := TypeBoolean;
+    end;
+    with Functions.AddNew('_Lesser') do begin
+      Params.AddNew('A', TypeInteger);
+      Params.AddNew('B', TypeInteger);
+      ResultType := TypeBoolean;
+    end;
+    with Functions.AddNew('_Higher') do begin
+      Params.AddNew('A', TypeInteger);
+      Params.AddNew('B', TypeInteger);
+      ResultType := TypeBoolean;
+    end;
+    with Functions.AddNew('_LesserOrEqual') do begin
+      Params.AddNew('A', TypeInteger);
+      Params.AddNew('B', TypeInteger);
+      ResultType := TypeBoolean;
+    end;
+    with Functions.AddNew('_HigherOrEqual') do begin
+      Params.AddNew('A', TypeInteger);
+      Params.AddNew('B', TypeInteger);
+      ResultType := TypeBoolean;
+    end;
+    with Functions.AddNew('_Shr') do begin
+      Params.AddNew('A', TypeInteger);
+      Params.AddNew('B', TypeInteger);
+      ResultType := TypeInteger;
+    end;
+    with Functions.AddNew('_Shl') do begin
+      Params.AddNew('A', TypeInteger);
+      Params.AddNew('B', TypeInteger);
+      ResultType := TypeInteger;
+    end;
+    with Functions.AddNew('_And') do begin
+      Params.AddNew('A', TypeInteger);
+      Params.AddNew('B', TypeInteger);
+      ResultType := TypeInteger;
+    end;
+    with Functions.AddNew('_Or') do begin
+      Params.AddNew('A', TypeInteger);
+      Params.AddNew('B', TypeInteger);
+      ResultType := TypeInteger;
+    end;
+    with Functions.AddNew('_Xor') do begin
+      Params.AddNew('A', TypeInteger);
+      Params.AddNew('B', TypeInteger);
+      ResultType := TypeInteger;
     end;
   end;
@@ -133 +202 @@
 function TParser.ParseProgram(SystemBlock: TBlock; out Prog: TProgram): Boolean;
 begin
+  Result := False;
 end;
 

branches/interpreter2/USource.pas

@@ -242 +242 @@
   end;
 
-  TExpressionOperator = (eoAdd, eoSub, eoMultiply, eoDivide, eoModulo, eoAnd, eoXor,
-    eoOr, eoShl, eoShr, eoEqual, eoNotEqual);
+  TExpressionOperator = (eoNone, eoAdd, eoSub, eoMultiply, eoDivide, eoIntDivide,
+    eoModulo, eoAnd, eoXor, eoOr, eoShl, eoShr, eoEqual, eoNotEqual, eoLesser,
+    eoHigher, eoLesserOrEqual, eoHigherOrEqual, eoNot);
 
   { TExpression }
@@ -270 +271 @@
   end;
 
-  TExpressionOperandType = (otVariableRef, otConstantRef, otConstantDirect, otFunctionCall);
+  TExpressionOperandType = (otVariableRef, otConstantRef, otConstantDirect,
+    otFunctionCall);
 
   { TExpressionOperand }
@@ -288 +290 @@
     function GetType: TType; override;
     constructor Create;
+    destructor Destroy; override;
+  end;
+
+  { TExpressionBrackets }
+
+  TExpressionBrackets = class(TExpression)
+    Expression: TExpression;
+    procedure GetValue(Index: Integer; out Value); override;
+    function GetField(Index: Integer): TField; override;
+    procedure SetValue(Index: Integer; var Value); override;
+    function GetType: TType; override;
     destructor Destroy; override;
   end;
@@ -442 +455 @@
       'Integer', 'Float', 'Color', 'Time', 'Date', 'DateTime', 'Enumeration',
       'Reference');
+    ExpressionOperatorText: array[TExpressionOperator] of string = ('', '+',
+      '-', '*', '/', 'div', 'mod', 'and', 'xor', 'or', 'shl',
+      'shr', '=', '<>', '<', '>', '<=','>=', 'not');
+    ExpressionOperatorFuncText: array[TExpressionOperator] of string = ('', '_Add',
+      '_Sub', '_Mul', '_Div', '_IntDiv', '_Mod', '_And', '_Xor', '_Or', '_Shl',
+      '_Shr', '_Equal', '_NotEqual', '_Lesser', '_Higher', '_LesserOrEqual',
+      '_HigherOrEqual', '_Not');
+
+  function GetOperatorByName(Name: string): TExpressionOperator;
 
 
@@ -452 +474 @@
   SYes = 'Yes';
   SNo = 'No';
+
+function GetOperatorByName(Name: string): TExpressionOperator;
+var
+  I: TExpressionOperator;
+begin
+  Result := eoNone;
+  for I := Succ(Low(TExpressionOperator)) to High(TExpressionOperator) do begin
+    if ExpressionOperatorText[I] = Name then begin
+      Result := I;
+      Break;
+    end;
+  end;
+end;
+
+{ TExpressionBrackets }
+
+procedure TExpressionBrackets.GetValue(Index: Integer; out Value);
+begin
+  if Index = 0 then begin
+    TExpression(Value) := Expression;
+  end
+  else inherited;
+end;
+
+function TExpressionBrackets.GetField(Index: Integer): TField;
+begin
+  if Index = 0 then Result := TField.Create(dtObject, 'Expression')
+  else inherited;
+end;
+
+procedure TExpressionBrackets.SetValue(Index: Integer; var Value);
+begin
+  if Index = 0 then begin
+    Expression := TExpression(Value);
+  end
+  else inherited;
+end;
+
+function TExpressionBrackets.GetType: TType;
+begin
+  Result := Expression.GetType;
+end;
+
+destructor TExpressionBrackets.Destroy;
+begin
+  FreeAndNil(Expression);
+  inherited;
+end;
 
 { TReturn }
@@ -1017 +1087 @@
 function TExpressionOperation.GetFunctionName: string;
 begin
-  if Operation = eoAdd then Result := '_Add'
-  else if Operation = eoSub then Result := '_Sub'
-  else if Operation = eoEqual then Result := '_Equal'
-  else if Operation = eoNotEqual then Result := '_NotEqual'
-  else raise Exception.Create('Unsupported operation type.');
+  Result := ExpressionOperatorFuncText[Operation];
 end;
 

branches/interpreter2/UTokenizer.pas

@@ -53 +53 @@
     function GetNext: TToken;
     function CheckNext(Text: string; Kind: TTokenKind): Boolean;
+    function CheckNextAndRead(Text: string; Kind: TTokenKind): Boolean;
     function CheckNextKind(Kind: TTokenKind): Boolean;
+    function CheckNextKindAndRead(Kind: TTokenKind): Boolean;
     procedure Expect(Text: string; Kind: TTokenKind);
     procedure Error(Text: string);
@@ -111 +113 @@
   Result := (C = ';') or (C = '.') or (C = '(') or (C = ')') or (C = '=') or
     (C = ':') or (C = '+') or (C = '-') or (C = ',') or (C = '/') or
-    (C = '<') or (C = '>');
+    (C = '<') or (C = '>') or (C = '*');
 end;
 
 function TTokenizer.IsSpecialSymbol2(Text: string): Boolean;
 begin
-  Result := (Text = ':=') or (Text = '//') or (Text = '<>');
+  Result := (Text = ':=') or (Text = '//') or (Text = '<>') or (Text = '<=') or
+    (Text = '>=');
 end;
 
@@ -141 +144 @@
 function TTokenizer.IsOperator(Text: string): Boolean;
 begin
-  Result := (Text = '+') or (Text = '-') or (Text = '=') or (Text = '<>');
+  Result := (Text = '+') or (Text = '-') or (Text = '=') or (Text = '<>') or
+    (Text = '*') or (Text = '/') or (Text = 'div') or (Text = '<=') or
+    (Text = '>=') or (Text = 'mod') or (Text = 'shl') or (Text = 'shr') or
+    (Text = 'and') or (Text = 'or') or (Text = 'xor') or (Text = 'not') or
+    (Text = '>') or (Text = '<');
 end;
 
@@ -270 +277 @@
 end;
 
+function TTokenizer.CheckNextAndRead(Text: string; Kind: TTokenKind): Boolean;
+var
+  LastPos: TTokenizerPos;
+  Token: TToken;
+begin
+  LastPos := Pos;
+  Token := GetNext;
+  Result := (Token.Text = Text) and (Token.Kind = Kind);
+  if not Result then Pos := LastPos;
+end;
+
 function TTokenizer.CheckNextKind(Kind: TTokenKind): Boolean;
 var
@@ -281 +299 @@
 end;
 
+function TTokenizer.CheckNextKindAndRead(Kind: TTokenKind): Boolean;
+var
+  LastPos: TTokenizerPos;
+  Token: TToken;
+begin
+  LastPos := Pos;
+  Token := GetNext;
+  Result := Token.Kind = Kind;
+  if not Result then Pos := LastPos;
+end;
+
 procedure TTokenizer.Expect(Text: string; Kind: TTokenKind);
 var