Changeset 13 for branches/DelphiToC

Timestamp:

Apr 9, 2009, 9:53:40 AM (16 years ago)

Author:

george

Message:

• Upraveno: Rozdělení původního kódu do více tříd.

Location:

branches/DelphiToC

Files:

• . (modified) (1 prop)
• DelphiToC.dpr (modified) (1 diff)
• UAssemblerSource.pas (modified) (3 diffs)
• UCodeProducer.pas (added)
• UPascalCompiler.pas (added)
• UPascalParser.pas (added)
• UPascalSource.pas (modified) (17 diffs)

branches/DelphiToC/DelphiToC.dpr

@@ -7 +7 @@
   UPascalSource in 'UPascalSource.pas',
   UCSource in 'UCSource.pas',
-  UAssemblerSource in 'UAssemblerSource.pas';
+  UAssemblerSource in 'UAssemblerSource.pas',
+  UCodeProducer in 'UCodeProducer.pas',
+  UPascalCompiler in 'UPascalCompiler.pas',
+  UPascalParser in 'UPascalParser.pas';
 
 {$R *.res}
 
+{$WARN SYMBOL_PLATFORM OFF}
 begin
   ReportMemoryLeaksOnShutdown := DebugHook <> 0;

branches/DelphiToC/UAssemblerSource.pas

@@ -2 +2 @@
 
 interface
+
+uses
+  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
+  Dialogs, StdCtrls, UPascalSource, UCodeProducer;
 
 type
@@ -11 +15 @@
   end;
 
+  TAssemblerLine = class
+    LabelName: string;
+    Instruction: string;
+    Operand1: string;
+    Operand2: string;
+    SourceCode: string;
+    function AsString: string;
+  end;
+
+  TAssemblerProducer = class(TCodeProducer)
+    AssemblyCode: TList; // TList<TAssemblerLine>
+    destructor Destroy; override;
+  private
+    procedure AddInstruction(LabelName, Instruction, Operand1,
+      Operand2: string);
+    procedure GenerateCommonBlock(CommonBlock: TCommonBlock; LabelPrefix: string);
+    procedure GenerateExpression(Expression: TExpression; LabelPrefix: string);
+    procedure GenerateProgram(ProgramBlock: TProgram);
+  end;
+
+
 implementation
+
+
+{ TAssemblerLine }
+
+function TAssemblerLine.AsString: string;
+begin
+  if LabelName = '' then LabelName := #9 else
+    LabelName := LabelName + ':'#9;
+  if Operand2 <> '' then Operand1 := Operand1 + ', ';
+
+  Result := LabelName + Instruction + ' ' + Operand1 + Operand2;
+end;
+
+{ TAssemblerProducer }
+
+procedure TAssemblerProducer.AddInstruction(LabelName, Instruction, Operand1,
+  Operand2: string);
+var
+  NewLine: TAssemblerLine;
+begin
+  NewLine := TAssemblerLine.Create;
+  AssemblyCode.Add(NewLine);
+  NewLine.LabelName := LabelName;
+  NewLine.Instruction := Instruction;
+  NewLine.Operand1 := Operand1;
+  NewLine.Operand2 := Operand2;
+end;
+
 
 (*
@@ -43 +96 @@
 *)
 
+destructor TAssemblerProducer.Destroy;
+var
+  I: Integer;
+begin
+  for I := 0 to AssemblyCode.Count - 1 do
+    TAssemblerLine(AssemblyCode[I]).Free;
+  AssemblyCode.Free;
+  inherited;
+end;
+
+procedure TAssemblerProducer.GenerateCommonBlock(CommonBlock: TCommonBlock; LabelPrefix: string);
+var
+  I: Integer;
+  LabelName: string;
+begin
+  with CommonBlock do
+  for I := 0 to Operations.Count - 1 do
+  with TOperation(Operations[I]) do begin
+    if Referenced then LabelName := Name + '_L' + IntToStr(I)
+      else LabelName := '';
+    case Instruction of
+      inJump: begin
+        AddInstruction(LabelName, 'JMP', Name + '_L' + IntToStr(GotoAddress), '');
+      end;
+      inConditionalJump: begin
+        GenerateExpression(ExpressionTree, LabelPrefix + '_L' + IntToStr(GotoAddress));
+        AddInstruction(LabelName, 'BRCS', Name + '_L' + IntToStr(GotoAddress), '');
+      end;
+      inExpressionEvaluation: begin
+        if LabelName <> '' then AddInstruction(LabelName, '', '', '');
+        GenerateExpression(ExpressionTree, Name + '_L' + IntToStr(GotoAddress));
+      end;
+      inReturn:
+        AddInstruction(LabelName, 'RET', '', '');
+    end;
+  end;
+end;
+
+procedure TAssemblerProducer.GenerateExpression(Expression: TExpression; LabelPrefix: string);
+var
+  I: Integer;
+begin
+  with Expression do
+  case NodeType of
+    ntNone: ;
+    ntVariable: if Assigned(Variable) then AddInstruction('', 'GETVAR', Variable.Name, '');
+    nTFunction: AddInstruction('', 'CALL', Method.Name, '');
+    ntConstant: AddInstruction('', 'CONST', '', '');
+    ntOperator: begin
+      for I := 0 to SubItems.Count - 1 do
+        GenerateExpression(TExpression(SubItems[I]), LabelPrefix);
+      if OperatorName = '+' then AddInstruction('', 'ADD', '', '')
+      else if OperatorName = '-' then AddInstruction('', 'SUB', '', '')
+      else if OperatorName = '*' then AddInstruction('', 'MUL', '', '')
+      else if OperatorName = '/' then AddInstruction('', 'DIV', '', '')
+      else if OperatorName = 'div' then AddInstruction('', 'DIV', '', '')
+      else if OperatorName = 'mod' then AddInstruction('', 'MOD', '', '')
+      else if OperatorName = 'xor' then AddInstruction('', 'XOR', '', '')
+      else if OperatorName = 'or' then AddInstruction('', 'OR', '', '')
+      else if OperatorName = 'and' then AddInstruction('', 'AND', '', '')
+      else if OperatorName = 'not' then AddInstruction('', 'NEG', '', '')
+      else if OperatorName = ':=' then AddInstruction('', 'ST', '', '')
+      else if OperatorName = '>' then AddInstruction('', 'CP', '', '')
+      else if OperatorName = '>=' then AddInstruction('', 'CP', '', '')
+      else if OperatorName = '<' then AddInstruction('', 'CP', '', '')
+      else if OperatorName = '<=' then AddInstruction('', 'CP', '', '')
+      else if OperatorName = '=' then AddInstruction('', 'TST', '', '')
+      else if OperatorName = '<>' then AddInstruction('', 'CP', '', '');
+    end;
+  end;
+end;
+
+procedure TAssemblerProducer.GenerateProgram(ProgramBlock: TProgram);
+var
+  I: Integer;
+begin
+  with ProgramBlock do
+  for I := 0 to Modules.Count - 1 do
+    GenerateCommonBlock(TModule(Modules[I]), '');
+end;
+
+
+
+
 end.

branches/DelphiToC/UPascalSource.pas

@@ -15 +15 @@
     inReturn);
 
-  TNodeType = (ntNone, ntVariable, nTFunction, ntConstant, ntOperator);
+  TNodeType = (ntNone, ntVariable, ntFunction, ntConstant, ntOperator);
 
   TValue = array of Byte;
 
-  TCompiler = class;
   TCommonBlock = class;
   TTypeList = class;
@@ -42 +41 @@
     Methods: TFunctionList;
     Operations: TOperationList;
-    procedure AllocateMemory;
     constructor Create; virtual;
     destructor Destroy; override;
-    procedure ParseDefinitions(Compiler: TCompiler);
-    function ParseExpression(Compiler: TCompiler): TExpression;
-    procedure ParseProgramCode(Compiler: TCompiler);
-    procedure ParseOperation(Compiler: TCompiler);
-    procedure GenerateAssembler(Compiler: TCompiler; LabelPrefix: string);
     procedure CheckReferences;
   end;
@@ -58 +51 @@
     Size: Integer;
     UsedType: TType;
-    procedure Parse(Compiler: TCompiler);
   end;
 
   TTypeList = class(TList)
     Parent: TCommonBlock;
-    procedure Parse(Compiler: TCompiler);
     function Search(Name: string): TType;
   end;
@@ -71 +62 @@
     ValueType: TType;
     Value: TValue;
-    procedure Parse(Compiler: TCompiler);
   end;
 
@@ -77 +67 @@
     Parent: TCommonBlock;
     function Search(Name: string): TConstant;
-    procedure Parse(Compiler: TCompiler);
   end;
 
@@ -84 +73 @@
     ValueType: TType;
     Value: TValue;
-    procedure Parse(Compiler: TCompiler);
   end;
 
   TVariableList = class(TList)
     Parent: TCommonBlock;
-    procedure Parse(Compiler: TCompiler);
     function Search(Name: string): TVariable;
   end;
@@ -103 +90 @@
     constructor Create;
     destructor Destroy; override;
-    procedure GenerateAssembler(Compiler: TCompiler; LabelPrefix: string);
   end;
 
@@ -112 +98 @@
     Negative: Boolean;
     Referenced: Boolean;
+    destructor Destroy; override;
   end;
 
   TOperationList = class(TList)
-
+    destructor Destroy; override;
   end;
 
   TFunction = class(TCommonBlock)
+  public
     Parameters: TList; // TList<TParameter>
     ResultType: TType;
     constructor Create; override;
     destructor Destroy; override;
-    procedure Parse(Compiler: TCompiler);
   end;
 
   TFunctionList = class(TList)
     Parent: TCommonBlock;
-    procedure Parse(Compiler: TCompiler);
     function Search(Name: string): TFunction;
   end;
 
   TModule = class(TCommonBlock)
+  public
     ModuleType: TModuleType;
     UsedModules: TList; // TList<TModule>
     constructor Create; override;
-    destructor Destroy; override;
-    procedure Parse(Compiler: TCompiler);
-  private
-    procedure ParseUnit(Compiler: TCompiler);
-    procedure ParseProgram(Compiler: TCompiler);
     procedure Clear;
+    destructor Destroy; override;
   end;
 
@@ -149 +132 @@
     constructor Create;
     destructor Destroy; override;
-    procedure Parse(Compiler: TCompiler);
-    procedure AllocateMemory;
-    procedure GenerateAssembler(Compiler: TCompiler);
-  end;
-
-  TAssemblerLine = class
-    LabelName: string;
-    Instruction: string;
-    Operand1: string;
-    Operand2: string;
-    SourceCode: string;
-    function AsString: string;
-  end;
-
-  TOnErrorMessage = procedure (Text: string) of object;
-
-  TCompiler = class
-  private
-    SourceCode: TStringList;
-    CodePosition: Integer;
-    ProgramCode: TProgram;
-    FOnErrorMessage: TOnErrorMessage;
-    procedure ErrorMessage(Text: string);
-    function IsAlphanumeric(Character: Char): Boolean;
-    function NextCode(Shift: Boolean = False): string;
-    function ReadCode: string;
-    procedure Expect(Code: string);
-    function IsWhiteSpace(Character: Char): Boolean;
-    function IsAlphabetic(Character: Char): Boolean;
-    function IsIdentificator(Text: string): Boolean;
-    function IsKeyword(Text: string): Boolean;
-    function IsOperator(Text: string): Boolean;
-    procedure GenerateAssemblyCode;
-    procedure AddInstruction(LabelName, Instruction, Operand1, Operand2: string);
-  public
-    AssemblyCode: TList; // TList<TAssemblerLine>
-    constructor Create;
-    procedure Compile(SourceCode: TStrings);
-    destructor Destroy; override;
-    property OnErrorMessage: TOnErrorMessage read FOnErrorMessage write FOnErrorMessage;
   end;
 
@@ -204 +147 @@
 implementation
 
-{ TCompiler }
-
-procedure TCompiler.AddInstruction(LabelName, Instruction, Operand1,
-  Operand2: string);
-var
-  NewLine: TAssemblerLine;
-begin
-  NewLine := TAssemblerLine.Create;
-  AssemblyCode.Add(NewLine);
-  NewLine.LabelName := LabelName;
-  NewLine.Instruction := Instruction;
-  NewLine.Operand1 := Operand1;
-  NewLine.Operand2 := Operand2;
-end;
-
-procedure TCompiler.Compile(SourceCode: TStrings);
-begin
-  Self.SourceCode.Assign(SourceCode);
-  CodePosition := 1;
-  ProgramCode.Parse(Self);
-  ProgramCode.AllocateMemory;
-  AssemblyCode.Clear;
-  GenerateAssemblyCode;
-end;
-
-constructor TCompiler.Create;
-begin
-  SourceCode := TStringList.Create;
-  AssemblyCode := TList.Create;
-  ProgramCode := TProgram.Create;
-end;
-
-destructor TCompiler.Destroy;
-begin
-  ProgramCode.Free;
-  AssemblyCode.Free;
-  SourceCode.Free;
-end;
-
-procedure TCompiler.ErrorMessage(Text: string);
-begin
-  if Assigned(FOnErrorMessage) then FOnErrorMessage(Text);  
-end;
-
-procedure TCompiler.Expect(Code: string);
-begin
-  if NextCode <> Code then begin
-    ErrorMessage('Expected ' + Code + ' but ' + NextCode + ' found.');
-  end;
-  ReadCode;
-end;
-
-procedure TCompiler.GenerateAssemblyCode;
-begin
-  ProgramCode.GenerateAssembler(Self);
-end;
-
-function TCompiler.IsAlphabetic(Character: Char): Boolean;
-begin
-  Result := (Character in ['a'..'z']) or (Character in ['A'..'Z']);
-end;
-
-function TCompiler.IsAlphanumeric(Character: Char): Boolean;
-begin
-  Result := IsAlphabetic(Character) or (Character in ['0'..'9']);
-end;
-
-function TCompiler.IsKeyword(Text: string): Boolean;
-var
-  I: Integer;
-begin
-  Result := False;
-  for I := 0 to High(Keywords) do
-    if Keywords[I] = Text then
-      Result := True;
-end;
-
-function TCompiler.IsOperator(Text: string): Boolean;
-var
-  I: Integer;
-begin
-  Result := False;
-  for I := 0 to High(Operators) do
-    if Operators[I] = Text then
-      Result := True;
-end;
-
-function TCompiler.IsIdentificator(Text: string): Boolean;
-var
-  I: Integer;
-begin
-  Result := True;
-  if Length(Text) = 0 then Result := False;
-  if IsKeyWord(Text) then Result := False;
-  if Length(Text) > 0 then
-    if not (Text[1] in ['a'..'z', 'A'..'Z', '%', '_']) then
-      Result := False;
-  for I := 2 to Length(Text) do
-    if not (Text[i] in ['a'..'z', 'A'..'Z', '0'..'9', '_']) then
-      Result := False;
-end;
-
-function TCompiler.IsWhiteSpace(Character: Char): Boolean;
-begin
-  Result := (Character = ' ') or (Character = #13) or (Character = #10);
-end;
-
-function TCompiler.NextCode(Shift: Boolean = False): string;
-var
-  I: Integer;
-//  II: Integer;
-  J: Integer;
-const
-  SpecChar: set of char = [';', '.', ',', ':', '(', ')', '[', ']', '+', '-', '/', '*',
-    '^', '=', '<' , '>' , '@'];
-  DoubleSpecChar : array[1..7] of string = (':=', '..', '<=', '>=', '<>', '+=', '-=');
-begin
-  Result := '';
-  J := CodePosition;
-  I := CodePosition;
-  with SourceCode do
-  while Result = '' do begin
-    while IsWhiteSpace(Text[I]) do Inc(I);
-    J := I;
-    if Copy(Text, J, 1) = '//' then begin
-      while (Text[I] <> #13) and (Text[I] <> #10) do Inc(I);
-      Result := '';
-    end else
-    if Copy(Text, J, 1) = '{' then begin
-      while (Text[I] <> '}') do Inc(I);
-      Result := '';
-    end else
-    if Copy(Text, J, 1) = '(*' then begin
-      while not((Text[I] = '*') and (Text[I + 1] = ')')) do Inc(I);
-      Result := '';
-    end else
-    if Text[J] = '''' then begin
-      I := J + 1;
-      while not ((Text[I] = '''') and (Text[I + 1] <> '''')) do Inc(I);
-      Inc(I);
-      Result := Copy(Text, J, I - J );
-    end else
-    if (Text[J] in SpecChar) then begin
-      if (Text[J + 1] in SpecChar) then begin
-        for I := 0 to High(DoubleSpecChar) do
-          if Copy(Text, J, 2) = DoubleSpecChar[I] then begin
-            Result := Copy(Text, J, 2);
-            Inc(J, 2);
-            Break;
-          end;
-        I := J;
-      end;
-      if Result = '' then begin
-        Result := Text[J];
-        Inc(I);
-      end;
-    end else begin
-      while IsAlphanumeric(Text[I]) do Inc(I);
-      Result := LowerCase(Copy(Text, J, I - J));
-    end;
-    J := I;
-  end;
-  if Shift then CodePosition := J;
-end;
-
-procedure TModule.ParseUnit(Compiler: TCompiler);
-begin
-  with Compiler do begin
-    Expect('unit');
-    with TModule(ProgramCode.Modules[0]) do begin
-      Name := ReadCode;
-      ModuleType := mdUnit;
-    end;
-    Expect(';');
-    //ParseInterface;
-    //ParseImplementation;
-  end;
-end;
-
-function TCompiler.ReadCode: string;
-begin
-  Result := NextCode(True);
-end;
-
 { TFunction }
 
@@ -404 +163 @@
 end;
 
-procedure TFunction.Parse(Compiler: TCompiler);
-begin
-  with Compiler do begin
-    if NextCode = 'var' then TVariableList(Variables).Parse(Compiler)
-    else if NextCode = 'const' then TConstantList(Constants).Parse(Compiler)
-    else if NextCode = 'type' then TTypeList(Types).Parse(Compiler)
-    else ProgramCode.Parse(Compiler);
-  end;
-end;
-
 { TProgram }
-
-procedure TProgram.AllocateMemory;
-var
-  I: Integer;
-begin
-  for I := 0 to Modules.Count - 1 do
-    TModule(Modules[I]).AllocateMemory;
-end;
 
 constructor TProgram.Create;
@@ -431 +172 @@
 
 destructor TProgram.Destroy;
-begin
-
-end;
-
-procedure TProgram.GenerateAssembler(Compiler: TCompiler);
 var
   I: Integer;
 begin
   for I := 0 to Modules.Count - 1 do
-    TModule(Modules[I]).GenerateAssembler(Compiler, '');
-end;
-
-procedure TProgram.Parse(Compiler: TCompiler);
-var
-  I: Integer;
-begin
-  for I := 0 to Modules.Count - 1 do
-    TModule(Modules[I]).Clear;
-  Modules.Clear;
-  with TModule(Modules[Modules.Add(TModule.Create)]) do begin
-    Name := 'main';
-    with TType(Types[Types.Add(TType.Create)]) do begin
-      Name := 'byte';
-      Size := 1;
-      UsedType := nil;
-    end;
-  end;
-  TModule(Modules[0]).Parse(Compiler);
+    TModule(Modules[I]).Free;
+  Device.Free;
 end;
 
 { TConstant }
 
-procedure TConstant.Parse(Compiler: TCompiler);
-begin
-
-end;
 
 { TConstantList }
-
-procedure TConstantList.Parse(Compiler: TCompiler);
-begin
-//  Compiler.Expect('const');
-//  while Compiler.IsIdentificator(Compiler.NextCode) do
-//    TConstant(Items[Add(TConstant.Create)]).Parse(Compiler);
-end;
 
 function TConstantList.Search(Name: string): TConstant;
@@ -511 +219 @@
   UsedModules.Destroy;
   inherited;
-end;
-
-procedure TModule.ParseProgram(Compiler: TCompiler);
-var
-  Identifier: string;
-begin
-  with Compiler do begin
-    if NextCode = 'program' then begin
-      Expect('program');
-      Name := ReadCode;
-      ModuleType := mdProgram;
-      Expect(';');
-    end else Name := '';
-
-    // Uses section
-    if NextCode = 'uses' then begin
-      Identifier := ReadCode;
-      while NextCode = ',' do begin
-        Identifier := ReadCode;
-
-      end;
-    end;
-    ParseDefinitions(Compiler);
-  end;
-end;
-
-procedure TModule.Parse(Compiler: TCompiler);
-begin
-  with Compiler do begin
-    if NextCode = 'program' then ParseProgram(Compiler)
-    else if NextCode = 'unit' then ParseUnit(Compiler)
-    else ParseProgram(Compiler);
-  end;
-end;
-
-procedure TCommonBlock.AllocateMemory;
-begin
-//  for I := 0 to Variables - 1 do
-    
 end;
 
@@ -586 +255 @@
 end;
 
-procedure TCommonBlock.GenerateAssembler(Compiler: TCompiler; LabelPrefix: string);
-var
-  I: Integer;
-  LabelName: string;
-begin
-  with Compiler do
-  for I := 0 to Operations.Count - 1 do 
-  with TOperation(Operations[I]) do begin
-    if Referenced then LabelName := Name + '_L' + IntToStr(I)
-      else LabelName := '';
-    case Instruction of
-      inJump: begin
-        AddInstruction(LabelName, 'JMP', Name + '_L' + IntToStr(GotoAddress), '');
-      end;
-      inConditionalJump: begin
-        ExpressionTree.GenerateAssembler(Compiler, LabelPrefix + '_L' + IntToStr(GotoAddress));
-        AddInstruction(LabelName, 'BRCS', Name + '_L' + IntToStr(GotoAddress), '');
-      end;
-      inExpressionEvaluation: begin
-        if LabelName <> '' then AddInstruction(LabelName, '', '', '');
-        ExpressionTree.GenerateAssembler(Compiler, Name + '_L' + IntToStr(GotoAddress));
-      end;
-      inReturn:
-        AddInstruction(LabelName, 'RET', '', '');
-    end;
-  end;
-end;
-
-procedure TCommonBlock.ParseDefinitions(Compiler: TCompiler);
-begin
-  with Compiler do begin
-    while NextCode <> '.' do begin
-      if NextCode = 'var' then TVariableList(Variables).Parse(Compiler)
-      else if NextCode = 'const' then TConstantList(Constants).Parse(Compiler)
-      else if NextCode = 'type' then TTypeList(Types).Parse(Compiler)
-      else begin
-        ParseProgramCode(Compiler);
-        Break;
-      end;
-    end;
-  end;
-end;
-
-function TCommonBlock.ParseExpression(Compiler: TCompiler): TExpression;
-var
-  Identifier: string;
-  NewVariable: TVariable;
-  Method: TFunction;
-  Constant: TConstant;
-//  Brackets: Integer;
-  Expressions: TList; // TList<TExpression>;
-  I: Integer;
-  II: Integer;
-begin
-  Expressions := TList.Create;
-  Expressions.Add(TExpression.Create);
-  with Compiler do begin
-    while ((NextCode <> ';') and (NextCode <> ',') and (not IsKeyWord(NextCode))) and
-      not (((NextCode = ')') or (NextCode = ']'))) do begin
-        Identifier := ReadCode;
-        if Identifier = '(' then begin
-          with TExpression(Expressions[Expressions.Count - 1]) do begin
-            SubItems[1] := ParseExpression(Compiler);
-          end;
-          with TExpression(Expressions.Items[Expressions.Add(TExpression.Create)]) do begin
-            SubItems[0] := TExpression(Expressions[Expressions.Count - 2]).SubItems[1];
-          end;
-          Expect(')');
-        end else
-        if IsOperator(Identifier) then begin
-          TExpression(Expressions[Expressions.Count - 1]).OperatorName := Identifier;
-          TExpression(Expressions[Expressions.Count - 1]).NodeType := ntOperator;
-        end else
-        if IsIdentificator(Identifier) then begin
-          NewVariable := Variables.Search(Identifier);
-          if Assigned(NewVariable) then begin
-            with TExpression(Expressions[Expressions.Count - 1]) do begin
-              SubItems[1] := TExpression.Create;
-              TExpression(SubItems[1]).NodeType := ntVariable;
-              TExpression(SubItems[1]).Variable := NewVariable;
-            end;
-            with TExpression(Expressions.Items[Expressions.Add(TExpression.Create)]) do begin
-              SubItems[0] := TExpression(Expressions[Expressions.Count - 2]).SubItems[1];
-            end;
-          end else begin
-            Method := Methods.Search(Identifier);
-            if Assigned(Method) then begin
-              with TExpression(Expressions[Expressions.Count - 1]) do begin
-                SubItems[1] := TExpression.Create;
-                if NextCode  = '(' then               // Method with parameters
-                with TExpression(SubItems[1]) do begin
-                  Expect('(');
-                  SubItems.Add(ParseExpression(Compiler));
-                  while NextCode = ',' do begin
-                    Expect(',');
-                    SubItems.Add(ParseExpression(Compiler));
-                  end;
-                  Expect(')');
-                end;
-                TExpression(SubItems[1]).NodeType := nTFunction;
-                TExpression(SubItems[1]).Method := Method;
-              end;
-              with TExpression(Expressions.Items[Expressions.Add(TExpression.Create)]) do begin
-                SubItems[0] := TExpression(Expressions[Expressions.Count - 2]).SubItems[1];
-              end;
-            end else begin
-              Constant := Constants.Search(Identifier);
-              if Assigned(Constant) then begin
-                with TExpression(Expressions[Expressions.Count - 1]) do begin
-                  SubItems[1] := TExpression.Create;
-                  TExpression(SubItems[1]).NodeType := ntConstant;
-                  TExpression(SubItems[1]).Value := Constant.Value;
-                end;
-                with TExpression(Expressions.Items[Expressions.Add(TExpression.Create)]) do begin
-                  SubItems[0] := TExpression(Expressions[Expressions.Count - 2]).SubItems[1];
-                end;
-              end else begin
-                ErrorMessage('Neznámý identifikátor: ' + Identifier);
-              end;
-            end;
-          end;
-        end else
-        begin
-                with TExpression(Expressions[Expressions.Count - 1]) do begin
-                  SubItems[1] := TExpression.Create;
-                  TExpression(SubItems[1]).NodeType := ntConstant;
-
-                  if Identifier[1] = '''' then begin
-                    SetLength(TExpression(SubItems[1]).Value, Length(Identifier));
-                    for I := 1 to Length(Identifier) do TExpression(SubItems[1]).Value[I - 1] := Byte(Identifier[I]);
-                  end else begin
-                    SetLength(TExpression(SubItems[1]).Value, 1);
-                    TExpression(SubItems[1]).Value[0] := StrToInt(Identifier);
-                  end;
-                end;
-                with TExpression(Expressions.Items[Expressions.Add(TExpression.Create)]) do begin
-                  SubItems[0] := TExpression(Expressions[Expressions.Count - 2]).SubItems[1];
-                end;
-        end;
-    end;
-
-    // Build expression tree
-    for II := 0 to High(Operators) do begin
-      I := 1;
-      while (I < Expressions.Count - 1) do begin
-        if not TExpression(Expressions[I]).Associated and
-          (TExpression(Expressions[I]).OperatorName = Operators[II]) then begin
-            TExpression(Expressions[I]).Associated := True;
-            TExpression(Expressions[I - 1]).SubItems[1] := Expressions[I];
-            TExpression(Expressions[I + 1]).SubItems[0] := Expressions[I];
-            Expressions.Delete(I);
-          end else Inc(I);
-      end;
-    end;
-  end;
-  Result := TExpression(Expressions[0]).SubItems[1];
-  TExpression(Expressions[0]).Destroy;
-  TExpression(Expressions[1]).Destroy;
-  Expressions.Destroy;
-end;
-
-procedure TCommonBlock.ParseOperation(Compiler: TCompiler);
-var
-  Identifier: string;
-  Variable: TVariable;
-  Method: TFunction;
-  First: TOperation;
-  Second: TOperation;
-  StartIndex: Integer;
-  LoopVaraible: TVariable;
-begin
-  with Compiler do begin
-    if NextCode = 'begin' then ParseProgramCode(Compiler)
-    else if NextCode = 'if' then begin
-      Expect('if');
-      with TOperation(Operations[Operations.Add(TOperation.Create)]) do begin
-        Instruction := inConditionalJump;
-        ExpressionTree := ParseExpression(Compiler);
-        Negative := True;
-      end;
-      First := Operations[Operations.Count - 1];
-      Expect('then');
-      ParseOperation(Compiler);
-      if NextCode = 'else' then begin
-        with TOperation(Operations[Operations.Add(TOperation.Create)]) do begin
-          Instruction := inJump;
-        end;
-        Second := Operations[Operations.Count - 1];
-        First.GotoAddress := Operations.Count;
-        Expect('else');
-        ParseOperation(Compiler);
-        Second.GotoAddress := Operations.Count;
-      end else First.GotoAddress := Operations.Count;
-    end
-    else if NextCode = 'repeat' then begin
-      Expect('repeat');
-      StartIndex := Operations.Count;
-      ParseOperation(Compiler);
-      Expect('until');
-      with TOperation(Operations[Operations.Add(TOperation.Create)]) do begin
-        Instruction := inConditionalJump;
-        ExpressionTree := ParseExpression(Compiler);
-        GotoAddress := StartIndex;
-      end;
-    end
-    else if NextCode = 'while' then begin
-      Expect('while');
-      with TOperation(Operations[Operations.Add(TOperation.Create)]) do begin
-        Instruction := inConditionalJump;
-        ExpressionTree := ParseExpression(Compiler);
-      end;
-      First := Operations[Operations.Count - 1];
-      StartIndex := Operations.Count - 1;
-      Expect('do');
-      ParseOperation(Compiler);
-      with TOperation(Operations[Operations.Add(TOperation.Create)]) do begin
-        Instruction := inJump;
-        GotoAddress := StartIndex;
-      end;
-      First.GotoAddress := Operations.Count;
-    end
-    else if NextCode = 'for' then begin
-      Expect('for');
-      with TOperation(Operations[Operations.Add(TOperation.Create)]) do begin
-        Instruction := inExpressionEvaluation;
-        ExpressionTree := ParseExpression(Compiler);
-        if (ExpressionTree.NodeType <> ntOperator) and
-          (ExpressionTree.OperatorName <> ':=') then ErrorMessage('Expected assigment in for loop');
-        if TExpression(TExpression(ExpressionTree).SubItems[0]).NodeType <> ntVariable then
-          ErrorMessage('Index in FOR loop have to be variable');
-        LoopVaraible := TExpression(TExpression(ExpressionTree).SubItems[0]).Variable;
-      end;
-      Expect('to');
-      with TOperation(Operations[Operations.Add(TOperation.Create)]) do begin
-        Instruction := inExpressionEvaluation;
-        ExpressionTree := TExpression.Create;
-        with ExpressionTree do begin
-          NodeType := ntOperator;
-          OperatorName := '=';
-          SubItems[0] := TExpression.Create;
-          with TExpression(SubItems[0]) do begin
-            NodeType := ntVariable;
-            Variable := LoopVaraible;
-          end;
-          SubItems[1] := ParseExpression(Compiler);
-        end;
-        Negative := True;
-      end;
-      First := Operations[Operations.Count - 1];
-      StartIndex := Operations.Count - 1;
-      Expect('do');
-      ParseOperation(Compiler);
-      with TOperation(Operations[Operations.Add(TOperation.Create)]) do begin
-        Instruction := inExpressionEvaluation;
-        ExpressionTree := TExpression.Create;
-        with ExpressionTree do begin
-          NodeType := ntOperator;
-          OperatorName := ':=';
-          SubItems[0] := TExpression.Create;
-          with TExpression(SubItems[0]) do begin
-            NodeType := ntVariable;
-            Variable := LoopVaraible;
-          end;
-          SubItems[1] := TExpression.Create;
-          with TExpression(SubItems[1]) do begin
-            NodeType := ntOperator;
-            OperatorName := '+';
-            SubItems[0] := TExpression.Create;
-            with TExpression(SubItems[0]) do begin
-              NodeType := ntVariable;
-              Variable := LoopVaraible;
-            end;
-            SubItems[1] := TExpression.Create;
-            with TExpression(SubItems[1]) do begin
-              NodeType := ntConstant;
-              SetLength(Value, 1);
-              Value[0] := 1;
-            end;
-          end;
-        end;
-      end;
-      with TOperation(Operations[Operations.Add(TOperation.Create)]) do begin
-        Instruction := inJump;
-        GotoAddress := StartIndex;
-      end;
-      First.GotoAddress := Operations.Count;
-    end
-    else begin
-      with TOperation(Operations[Operations.Add(TOperation.Create)]) do begin
-        Instruction := inExpressionEvaluation;
-        ExpressionTree := ParseExpression(Compiler);
-      end;
-    end;
-  end;
-end;
-
-procedure TCommonBlock.ParseProgramCode(Compiler: TCompiler);
-begin
-  with Compiler do begin
-    Expect('begin');
-    while NextCode <> 'end' do begin
-      ParseOperation(Compiler);
-      Expect(';');
-    end;
-    Expect('end');
-    with TOperation(Operations[Operations.Add(TOperation.Create)]) do begin
-      Instruction := inReturn;
-    end;
-  end;
-  CheckReferences;
-end;
-
 { TTypeList }
-
-procedure TTypeList.Parse(Compiler: TCompiler);
-begin
-  with Compiler do begin
-    Expect('type');
-    while IsIdentificator(NextCode) do
-      with TType(Items[Add(TType.Create)]) do begin
-        Parent := Self;
-        Parse(Compiler);
-      end;
-  end;
-end;
 
 function TTypeList.Search(Name: string): TType;
@@ -928 +273 @@
 { TVariableList }
 
-procedure TVariableList.Parse(Compiler: TCompiler);
-var
-  Identifiers: TStringList;
-  NewValueType: TType;
-  TypeName: string;
-  VariableName: string;
-  Variable: TVariable;
-  I: Integer;
-begin
-  Identifiers := TStringList.Create;
-  with Compiler do begin
-    Expect('var');
-    while IsIdentificator(NextCode) do begin
-      VariableName := ReadCode;
-      Variable := Search(VariableName);
-      if not Assigned(Variable) then begin
-        Identifiers.Add(VariableName);
-        while NextCode = ',' do begin
-          Expect(',');
-          Identifiers.Add(ReadCode);
-        end;
-      end else ErrorMessage('Pøedefinování existující promìnné.');
-      Expect(':');
-      TypeName := ReadCode;
-      NewValueType := Parent.Types.Search(TypeName);
-      if NewValueType = nil then ErrorMessage('Typ ' + TypeName + ' nebyl definován.')
-        else for I := 0 to Identifiers.Count - 1 do
-          with TVariable(Items[Add(TVariable.Create)]) do begin
-            Name := Identifiers[I];
-            ValueType := NewValueType;
-          end;
-      Expect(';');
-    end;
-  end;
-  Identifiers.Destroy;
-end;
-
 function TVariableList.Search(Name: string): TVariable;
 var
@@ -981 +289 @@
 { TVariable }
 
-procedure TVariable.Parse(Compiler: TCompiler);
-begin
-end;
-
 { TType }
 
-procedure TType.Parse(Compiler: TCompiler);
-begin
-  with Compiler do begin
-    Name := NextCode;
-    Expect('=');
-    UsedType := Parent.Search(NextCode);
-  end;
-end;
 
 { TFunctionList }
-
-procedure TFunctionList.Parse(Compiler: TCompiler);
-begin
-
-end;
 
 function TFunctionList.Search(Name: string): TFunction;
@@ -1031 +322 @@
 end;
 
-procedure TExpression.GenerateAssembler(Compiler: TCompiler; LabelPrefix: string);
-var
-  I: Integer;
-begin
-  with Compiler do
-  case NodeType of
-    ntNone: ;
-    ntVariable: if Assigned(Variable) then AddInstruction('', 'GETVAR', Variable.Name, '');
-    nTFunction: AddInstruction('', 'CALL', Method.Name, '');
-    ntConstant: AddInstruction('', 'CONST', '', '');
-    ntOperator: begin
-      for I := 0 to SubItems.Count - 1 do
-        TExpression(SubItems[I]).GenerateAssembler(Compiler, LabelPrefix);
-      if OperatorName = '+' then AddInstruction('', 'ADD', '', '')
-      else if OperatorName = '-' then AddInstruction('', 'SUB', '', '')
-      else if OperatorName = '*' then AddInstruction('', 'MUL', '', '')
-      else if OperatorName = '/' then AddInstruction('', 'DIV', '', '')
-      else if OperatorName = 'div' then AddInstruction('', 'DIV', '', '')
-      else if OperatorName = 'mod' then AddInstruction('', 'MOD', '', '')
-      else if OperatorName = 'xor' then AddInstruction('', 'XOR', '', '')
-      else if OperatorName = 'or' then AddInstruction('', 'OR', '', '')
-      else if OperatorName = 'and' then AddInstruction('', 'AND', '', '')
-      else if OperatorName = 'not' then AddInstruction('', 'NEG', '', '')
-      else if OperatorName = ':=' then AddInstruction('', 'ST', '', '')
-      else if OperatorName = '>' then AddInstruction('', 'CP', '', '')
-      else if OperatorName = '>=' then AddInstruction('', 'CP', '', '')
-      else if OperatorName = '<' then AddInstruction('', 'CP', '', '')
-      else if OperatorName = '<=' then AddInstruction('', 'CP', '', '')
-      else if OperatorName = '=' then AddInstruction('', 'TST', '', '')
-      else if OperatorName = '<>' then AddInstruction('', 'CP', '', '');
-    end;
-  end;
-end;
-
-{ TAssemblerLine }
-
-function TAssemblerLine.AsString: string;
-begin
-  if LabelName = '' then LabelName := #9 else
-    LabelName := LabelName + ':'#9;
-  if Operand2 <> '' then Operand1 := Operand1 + ', ';
-  
-  Result := LabelName + Instruction + ' ' + Operand1 + Operand2;
+{ TOperationList }
+
+destructor TOperationList.Destroy;
+var
+  I: Integer;
+begin
+  for I := 0 to Count - 1 do
+    TOperation(Items[I]).Free;
+  inherited;
+end;
+
+{ TOperation }
+
+destructor TOperation.Destroy;
+begin
+  inherited;
+  ExpressionTree.Free;
 end;