Changeset 2 for branches

Timestamp:

Nov 6, 2009, 10:24:38 AM (15 years ago)

Author:

george

Message:

• Přidáno: Třída pro obsluhu čísel s dynamickou velikostí.
• Přidáno: Struktury pro vytváření specifikace assembleru a strojových kódů.

Location:

branches/Z80

Files:

• . (modified) (1 prop)
• Compiler.bdsproj (deleted)
• Compiler.dpr (modified) (2 diffs)
• Compiler.dsk (deleted)
• Compiler.ico (added)
• Compiler.lpi (added)
• Compiler.lpr (added)
• Compiler.manifest (added)
• Compiler.rc (added)
• Example.asm (added)
• UDynamicNumber.pas (added)
• UZ80Compiler.pas (modified) (1 diff)

branches/Z80/Compiler.dpr

@@ -6 +6 @@
 {R-}
 {  $M 16384,0,655360   }
-
-uses
-  UZ80Compiler in 'UZ80Compiler.pas';
 
 CONST
@@ -455 +452 @@
          done := FALSE;
          WHILE (Length(line)>0) AND NOT done DO BEGIN
-            word := word + Upcase(line[1]);
+      word := word + Upcase(line[1]);
             Delete(line,1,1);
-            IF Length(line)>0 THEN
+      IF Length(line)>0 THEN
                done := Pos(Upcase(line[1]),AlphaNumeric)=0;
          END;

branches/Z80/UZ80Compiler.pas

@@ -1 +1 @@
 unit UZ80Compiler;
+
+{$mode Delphi}{$H+}
 
 interface
 
+uses
+  Classes, SysUtils, UDynamicNumber;
+
+type
+  TMaskedValue = class
+  private
+    function GetSize: Integer;
+    procedure SetSize(const AValue: Integer);
+  public
+    Value: TDynamicNumber;
+    Mask: TDynamicNumber;
+    property Size: Integer read GetSize write SetSize;
+  end;
+
+  TStringEnumeration = class
+    Values: TStringList;
+    constructor Create;
+    destructor Destroy; override;
+  end;
+
+  TOperandType = (otEnumeration, otConstant);
+
+  TOperand = class
+    OperandType: TOperandType;
+    MaskedValue: TMaskedValue;
+    Enumeration: TStringEnumeration;
+    constructor Create;
+    destructor Destroy; override;
+  end;
+
+  TOpcode = class
+    Name: string;
+    Cycles: Integer;
+    Operands: TList;
+    MaskedValue: TMaskedValue;
+    constructor Create;
+    destructor Destroy; override;
+  end;
+
+  TZ80Compiler = class
+  private
+    OperandEnumerations: TList;
+    Opcodes: TList;
+    MachineCode: TMemoryStream;
+    procedure InitOpcodes;
+  public
+    procedure Load(StringList: TStringList);
+    constructor Create;
+    destructor Destroy; override;
+  end;
+
 implementation
 
+{ TZ80Compiler }
+
+procedure TZ80Compiler.InitOpcodes;
+var
+  SigleRegistersEnum: TStringEnumeration;
+begin
+  SigleRegistersEnum := TStringEnumeration.Create;
+  with SigleRegistersEnum do begin
+    Values.Add('B');
+    Values.Add('C');
+    Values.Add('D');
+    Values.Add('E');
+    Values.Add('H');
+    Values.Add('L');
+    Values.Add('(HL)');
+    Values.Add('A');
+  end;
+  OperandEnumerations.Add(SigleRegistersEnum);
+
+  with TOpcode(Opcodes[Opcodes.Add(TOpcode.Create)]) do begin
+    Name := 'NOP';
+    with MaskedValue do begin
+      Value.Assign(0);
+      Mask.Assign($ff);
+    end;
+  end;
+  with TOpcode(Opcodes[Opcodes.Add(TOpcode.Create)]) do begin
+    Name := 'INC';
+    with MaskedValue do begin
+      Value.Assign($04);
+      Mask.Assign($c7);
+    end;
+    with TOperand(Operands[Operands.Add(TOperand.Create)]) do begin
+      OperandType := otEnumeration;
+      Enumeration := SigleRegistersEnum;
+      with MaskedValue do begin
+        Value.Assign($00);
+        Mask.Assign($38);
+      end;
+    end;
+  end;
+end;
+
+procedure TZ80Compiler.Load(StringList: TStringList);
+var
+  I: Integer;
+begin
+  for I := 0 to StringList.Count - 1 do begin
+
+  end;
+end;
+
+constructor TZ80Compiler.Create;
+begin
+  MachineCode := TMemoryStream.Create;
+  Opcodes := TList.Create;
+  OperandEnumerations := TList.Create;
+  InitOpcodes;
+end;
+
+destructor TZ80Compiler.Destroy;
+var
+  I: Integer;
+begin
+  for I := 0 to Opcodes.Count - 1 do
+    TOpcode(Opcodes[I]).Destroy;
+  Opcodes.Destroy;
+  for I := 0 to OperandEnumerations.Count - 1 do
+    TStringEnumeration(OperandEnumerations[I]).Destroy;
+  OperandEnumerations.Destroy;
+  MachineCode.Destroy;
+  inherited Destroy;
+end;
+
+{ TMaskedValue }
+
+function TMaskedValue.GetSize: Integer;
+begin
+  Result := Value.Size;
+end;
+
+procedure TMaskedValue.SetSize(const AValue: Integer);
+begin
+  Value.Size := AValue;
+  Mask.Size := AValue;
+end;
+
+{ TOpcode }
+
+constructor TOpcode.Create;
+begin
+  MaskedValue := TMaskedValue.Create;
+end;
+
+destructor TOpcode.Destroy;
+var
+  I: Integer;
+begin
+  for I := 0 to Operands.Count - 1 do
+    TOperand(Operands[I]).Destroy;
+  Operands.Destroy;
+  MaskedValue.Destroy;
+  inherited Destroy;
+end;
+
+{ TOperand }
+
+constructor TOperand.Create;
+begin
+  MaskedValue := TMaskedValue.Create;
+  Enumeration := nil;
+end;
+
+destructor TOperand.Destroy;
+begin
+  MaskedValue.Destroy;
+  inherited Destroy;
+end;
+
+{ TStringEnumeration }
+
+constructor TStringEnumeration.Create;
+begin
+  Values := TStringList.Create;
+end;
+
+destructor TStringEnumeration.Destroy;
+begin
+  Values.Destroy;
+  inherited Destroy;
+end;
+
 end.